chrome/common/web_apps.cc

   1 // Copyright (c) 2011 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "chrome/common/web_apps.h"
   6
   7 #include <string>
   8 #include <vector>
   9
  10 #include "base/json/json_reader.h"
  11 #include "base/string16.h"
  12 #include "base/string_number_conversions.h"
  13 #include "base/string_split.h"
  14 #include "base/utf_string_conversions.h"
  15 #include "base/values.h"
  16 #include "chrome/common/json_schema_validator.h"
  17 #include "googleurl/src/gurl.h"
  18 #include "grit/common_resources.h"
  19 #include "grit/generated_resources.h"
  20 #include "third_party/WebKit/Source/WebKit/chromium/public/WebDocument.h"
  21 #include "third_party/WebKit/Source/WebKit/chromium/public/WebElement.h"
  22 #include "third_party/WebKit/Source/WebKit/chromium/public/WebFrame.h"
  23 #include "third_party/WebKit/Source/WebKit/chromium/public/WebNode.h"
  24 #include "third_party/WebKit/Source/WebKit/chromium/public/WebNodeList.h"
  25 #include "third_party/WebKit/Source/WebKit/chromium/public/WebString.h"
  26 #include "third_party/WebKit/Source/WebKit/chromium/public/WebURL.h"
  27 #include "ui/base/l10n/l10n_util.h"
  28 #include "ui/base/resource/resource_bundle.h"
  29 #include "ui/gfx/size.h"
  30 #include "webkit/glue/dom_operations.h"
  31
  32 using WebKit::WebDocument;
  33 using WebKit::WebElement;
  34 using WebKit::WebFrame;
  35 using WebKit::WebNode;
  36 using WebKit::WebNodeList;
  37 using WebKit::WebString;
  38
  39 namespace {
  40
  41 // Sizes a single size (the width or height) from a 'sizes' attribute. A size
  42 // matches must match the following regex: [1-9][0-9]*.
  43 static int ParseSingleIconSize(const string16& text) {
  44   // Size must not start with 0, and be between 0 and 9.
  45   if (text.empty() || !(text[0] >= L'1' && text[0] <= L'9'))
  46     return 0;
  47
  48   // Make sure all chars are from 0-9.
  49   for (size_t i = 1; i < text.length(); ++i) {
  50     if (!(text[i] >= L'0' && text[i] <= L'9'))
  51       return 0;
  52   }
  53   int output;
  54   if (!base::StringToInt(text, &output))
  55     return 0;
  56   return output;
  57 }
  58
  59 void AddInstallIcon(const WebElement& link,
  60                     std::vector<WebApplicationInfo::IconInfo>* icons) {
  61   WebString href = link.getAttribute("href");
  62   if (href.isNull() || href.isEmpty())
  63     return;
  64
  65   // Get complete url.
  66   GURL url = link.document().completeURL(href);
  67   if (!url.is_valid())
  68     return;
  69
  70   if (!link.hasAttribute("sizes"))
  71     return;
  72
  73   bool is_any = false;
  74   std::vector<gfx::Size> icon_sizes;
  75   if (!web_apps::ParseIconSizes(link.getAttribute("sizes"), &icon_sizes,
  76                                 &is_any) ||
  77       is_any ||
  78       icon_sizes.size() != 1) {
  79     return;
  80   }
  81   WebApplicationInfo::IconInfo icon_info;
  82   icon_info.width = icon_sizes[0].width();
  83   icon_info.height = icon_sizes[0].height();
  84   icon_info.url = url;
  85   icons->push_back(icon_info);
  86 }
  87
  88 }
  89
  90 const char WebApplicationInfo::kInvalidDefinitionURL[] =
  91     "Invalid application definition URL. Must be a valid relative URL or "
  92     "an absolute URL with the same origin as the document.";
  93 const char WebApplicationInfo::kInvalidLaunchURL[] =
  94     "Invalid value for property 'launch_url'. Must be a valid relative URL or "
  95     "an absolute URL with the same origin as the application definition.";
  96 const char WebApplicationInfo::kInvalidURL[] =
  97     "Invalid value for property 'urls[*]'. Must be a valid relative URL or "
  98     "an absolute URL with the same origin as the application definition.";
  99 const char WebApplicationInfo::kInvalidIconURL[] =
 100     "Invalid value for property 'icons.*'. Must be a valid relative URL or "
 101     "an absolute URL with the same origin as the application definition.";
 102
 103 WebApplicationInfo::WebApplicationInfo() {
 104   is_bookmark_app = false;
 105 }
 106
 107 WebApplicationInfo::~WebApplicationInfo() {
 108 }
 109
 110
 111 namespace web_apps {
 112
 113 gfx::Size ParseIconSize(const string16& text) {
 114   std::vector<string16> sizes;
 115   base::SplitStringDontTrim(text, L'x', &sizes);
 116   if (sizes.size() != 2)
 117     return gfx::Size();
 118
 119   return gfx::Size(ParseSingleIconSize(sizes[0]),
 120                    ParseSingleIconSize(sizes[1]));
 121 }
 122
 123 bool ParseIconSizes(const string16& text,
 124                     std::vector<gfx::Size>* sizes,
 125                     bool* is_any) {
 126   *is_any = false;
 127   std::vector<string16> size_strings;
 128   base::SplitStringAlongWhitespace(text, &size_strings);
 129   for (size_t i = 0; i < size_strings.size(); ++i) {
 130     if (EqualsASCII(size_strings[i], "any")) {
 131       *is_any = true;
 132     } else {
 133       gfx::Size size = ParseIconSize(size_strings[i]);
 134       if (size.width() <= 0 || size.height() <= 0)
 135         return false;  // Bogus size.
 136       sizes->push_back(size);
 137     }
 138   }
 139   if (*is_any && !sizes->empty()) {
 140     // If is_any is true, it must occur by itself.
 141     return false;
 142   }
 143   return (*is_any || !sizes->empty());
 144 }
 145
 146 bool ParseWebAppFromWebDocument(WebFrame* frame,
 147                                 WebApplicationInfo* app_info,
 148                                 string16* error) {
 149   WebDocument document = frame->document();
 150   if (document.isNull())
 151     return true;
 152
 153   WebElement head = document.head();
 154   if (head.isNull())
 155     return true;
 156
 157   GURL document_url = document.url();
 158   WebNodeList children = head.childNodes();
 159   for (unsigned i = 0; i < children.length(); ++i) {
 160     WebNode child = children.item(i);
 161     if (!child.isElementNode())
 162       continue;
 163     WebElement elem = child.to<WebElement>();
 164
 165     if (elem.hasTagName("link")) {
 166       std::string rel = elem.getAttribute("rel").utf8();
 167       // "rel" attribute may use either "icon" or "shortcut icon".
 168       // see also
 169       //   <http://en.wikipedia.org/wiki/Favicon>
 170       //   <http://dev.w3.org/html5/spec/Overview.html#rel-icon>
 171       if (LowerCaseEqualsASCII(rel, "icon") ||
 172           LowerCaseEqualsASCII(rel, "shortcut icon")) {
 173         AddInstallIcon(elem, &app_info->icons);
 174       } else if (LowerCaseEqualsASCII(rel, "chrome-application-definition")) {
 175         std::string definition_url_string(elem.getAttribute("href").utf8());
 176         GURL definition_url;
 177         if (!(definition_url =
 178               document_url.Resolve(definition_url_string)).is_valid() ||
 179             definition_url.GetOrigin() != document_url.GetOrigin()) {
 180           *error = UTF8ToUTF16(WebApplicationInfo::kInvalidDefinitionURL);
 181           return false;
 182         }
 183
 184         // If there is a definition file, all attributes come from it.
 185         *app_info = WebApplicationInfo();
 186         app_info->manifest_url = definition_url;
 187         return true;
 188       }
 189     } else if (elem.hasTagName("meta") && elem.hasAttribute("name")) {
 190       std::string name = elem.getAttribute("name").utf8();
 191       WebString content = elem.getAttribute("content");
 192       if (name == "application-name") {
 193         app_info->title = content;
 194       } else if (name == "description") {
 195         app_info->description = content;
 196       } else if (name == "application-url") {
 197         std::string url = content.utf8();
 198         app_info->app_url = document_url.is_valid() ?
 199             document_url.Resolve(url) : GURL(url);
 200         if (!app_info->app_url.is_valid())
 201           app_info->app_url = GURL();
 202       }
 203     }
 204   }
 205
 206   return true;
 207 }
 208
 209 bool ParseWebAppFromDefinitionFile(Value* definition_value,
 210                                    WebApplicationInfo* web_app,
 211                                    string16* error) {
 212   CHECK(web_app->manifest_url.is_valid());
 213
 214   int error_code = 0;
 215   std::string error_message;
 216   scoped_ptr<Value> schema(
 217       base::JSONReader::ReadAndReturnError(
 218           ResourceBundle::GetSharedInstance().GetRawDataResource(
 219               IDR_WEB_APP_SCHEMA).as_string(),
 220           false,  // disallow trailing comma
 221           &error_code,
 222           &error_message));
 223   CHECK(schema.get())
 224       << "Error parsing JSON schema: " << error_code << ": " << error_message;
 225   CHECK(schema->IsType(Value::TYPE_DICTIONARY))
 226       << "schema root must be dictionary.";
 227
 228   JSONSchemaValidator validator(static_cast<DictionaryValue*>(schema.get()));
 229
 230   // We allow extra properties in the schema for easy compat with other systems,
 231   // and for forward compat with ourselves.
 232   validator.set_default_allow_additional_properties(true);
 233
 234   if (!validator.Validate(definition_value)) {
 235     *error = UTF8ToUTF16(
 236         validator.errors()[0].path + ": " + validator.errors()[0].message);
 237     return false;
 238   }
 239
 240   // This must be true because the schema requires the root value to be a
 241   // dictionary.
 242   CHECK(definition_value->IsType(Value::TYPE_DICTIONARY));
 243   DictionaryValue* definition = static_cast<DictionaryValue*>(definition_value);
 244
 245   // Parse launch URL. It must be a valid URL in the same origin as the
 246   // manifest.
 247   std::string app_url_string;
 248   GURL app_url;
 249   CHECK(definition->GetString("launch_url", &app_url_string));
 250   if (!(app_url = web_app->manifest_url.Resolve(app_url_string)).is_valid() ||
 251       app_url.GetOrigin() != web_app->manifest_url.GetOrigin()) {
 252     *error = UTF8ToUTF16(WebApplicationInfo::kInvalidLaunchURL);
 253     return false;
 254   }
 255
 256   // Parse out the permissions if present.
 257   std::vector<std::string> permissions;
 258   ListValue* permissions_value = NULL;
 259   if (definition->GetList("permissions", &permissions_value)) {
 260     for (size_t i = 0; i < permissions_value->GetSize(); ++i) {
 261       std::string permission;
 262       CHECK(permissions_value->GetString(i, &permission));
 263       permissions.push_back(permission);
 264     }
 265   }
 266
 267   // Parse out the URLs if present.
 268   std::vector<GURL> urls;
 269   ListValue* urls_value = NULL;
 270   if (definition->GetList("urls", &urls_value)) {
 271     for (size_t i = 0; i < urls_value->GetSize(); ++i) {
 272       std::string url_string;
 273       GURL url;
 274       CHECK(urls_value->GetString(i, &url_string));
 275       if (!(url = web_app->manifest_url.Resolve(url_string)).is_valid() ||
 276           url.GetOrigin() != web_app->manifest_url.GetOrigin()) {
 277         *error = UTF8ToUTF16(
 278             JSONSchemaValidator::FormatErrorMessage(
 279                 WebApplicationInfo::kInvalidURL, base::Uint64ToString(i)));
 280         return false;
 281       }
 282       urls.push_back(url);
 283     }
 284   }
 285
 286   // Parse out the icons if present.
 287   std::vector<WebApplicationInfo::IconInfo> icons;
 288   DictionaryValue* icons_value = NULL;
 289   if (definition->GetDictionary("icons", &icons_value)) {
 290     for (DictionaryValue::key_iterator iter = icons_value->begin_keys();
 291          iter != icons_value->end_keys(); ++iter) {
 292       // Ignore unknown properties. Better for forward compat.
 293       int size = 0;
 294       if (!base::StringToInt(*iter, &size) || size < 0 || size > 128)
 295         continue;
 296
 297       std::string icon_url_string;
 298       GURL icon_url;
 299       if (!icons_value->GetString(*iter, &icon_url_string) ||
 300           !(icon_url = web_app->manifest_url.Resolve(
 301               icon_url_string)).is_valid()) {
 302         *error = UTF8ToUTF16(
 303             JSONSchemaValidator::FormatErrorMessage(
 304                 WebApplicationInfo::kInvalidIconURL, base::IntToString(size)));
 305         return false;
 306       }
 307
 308       WebApplicationInfo::IconInfo icon;
 309       icon.url = icon_url;
 310       icon.width = size;
 311       icon.height = size;
 312
 313       icons.push_back(icon);
 314     }
 315   }
 316
 317   CHECK(definition->GetString("name", &web_app->title));
 318   definition->GetString("description", &web_app->description);
 319   definition->GetString("launch_container", &web_app->launch_container);
 320   web_app->app_url = app_url;
 321   web_app->urls = urls;
 322   web_app->permissions = permissions;
 323   web_app->icons = icons;
 324
 325   return true;
 326
 327 }
 328
 329 }  // namespace web_apps