chrome/renderer/extensions/webstore_bindings.cc

   1 // Copyright (c) 2012 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/renderer/extensions/webstore_bindings.h"
   6
   7 #include "base/strings/string_util.h"
   8 #include "chrome/common/extensions/api/webstore/webstore_api_constants.h"
   9 #include "chrome/common/extensions/chrome_extension_messages.h"
  10 #include "chrome/common/extensions/extension_constants.h"
  11 #include "content/public/renderer/render_view.h"
  12 #include "extensions/common/extension.h"
  13 #include "extensions/renderer/script_context.h"
  14 #include "third_party/WebKit/public/web/WebDocument.h"
  15 #include "third_party/WebKit/public/web/WebElement.h"
  16 #include "third_party/WebKit/public/web/WebNode.h"
  17 #include "third_party/WebKit/public/web/WebNodeList.h"
  18 #include "third_party/WebKit/public/web/WebUserGestureIndicator.h"
  19 #include "url/gurl.h"
  20 #include "v8/include/v8.h"
  21
  22 using blink::WebDocument;
  23 using blink::WebElement;
  24 using blink::WebFrame;
  25 using blink::WebNode;
  26 using blink::WebNodeList;
  27 using blink::WebUserGestureIndicator;
  28
  29 namespace extensions {
  30
  31 namespace {
  32
  33 const char kWebstoreLinkRelation[] = "chrome-webstore-item";
  34
  35 const char kNotInTopFrameError[] =
  36     "Chrome Web Store installations can only be started by the top frame.";
  37 const char kNotUserGestureError[] =
  38     "Chrome Web Store installations can only be initated by a user gesture.";
  39 const char kNoWebstoreItemLinkFoundError[] =
  40     "No Chrome Web Store item link found.";
  41 const char kInvalidWebstoreItemUrlError[] =
  42     "Invalid Chrome Web Store item URL.";
  43
  44 // chrome.webstore.install() calls generate an install ID so that the install's
  45 // callbacks may be fired when the browser notifies us of install completion
  46 // (successful or not) via OnInlineWebstoreInstallResponse.
  47 int g_next_install_id = 0;
  48
  49 } // anonymous namespace
  50
  51 WebstoreBindings::WebstoreBindings(ScriptContext* context)
  52     : ObjectBackedNativeHandler(context), ChromeV8ExtensionHandler(context) {
  53   RouteFunction("Install",
  54                 base::Bind(&WebstoreBindings::Install, base::Unretained(this)));
  55 }
  56
  57 void WebstoreBindings::Install(
  58     const v8::FunctionCallbackInfo<v8::Value>& args) {
  59   content::RenderView* render_view = context()->GetRenderView();
  60   if (!render_view)
  61     return;
  62
  63   // The first two arguments indicate whether or not there are install stage
  64   // or download progress listeners.
  65   int listener_mask = 0;
  66   CHECK(args[0]->IsBoolean());
  67   if (args[0]->BooleanValue())
  68     listener_mask |= api::webstore::INSTALL_STAGE_LISTENER;
  69   CHECK(args[1]->IsBoolean());
  70   if (args[1]->BooleanValue())
  71     listener_mask |= api::webstore::DOWNLOAD_PROGRESS_LISTENER;
  72
  73   std::string preferred_store_link_url;
  74   if (!args[2]->IsUndefined()) {
  75     CHECK(args[2]->IsString());
  76     preferred_store_link_url = std::string(*v8::String::Utf8Value(args[2]));
  77   }
  78
  79   std::string webstore_item_id;
  80   std::string error;
  81   WebFrame* frame = context()->web_frame();
  82
  83   if (!GetWebstoreItemIdFromFrame(
  84       frame, preferred_store_link_url, &webstore_item_id, &error)) {
  85     args.GetIsolate()->ThrowException(
  86         v8::String::NewFromUtf8(args.GetIsolate(), error.c_str()));
  87     return;
  88   }
  89
  90   int install_id = g_next_install_id++;
  91
  92   Send(new ExtensionHostMsg_InlineWebstoreInstall(render_view->GetRoutingID(),
  93                                                   install_id,
  94                                                   GetRoutingID(),
  95                                                   webstore_item_id,
  96                                                   frame->document().url(),
  97                                                   listener_mask));
  98
  99   args.GetReturnValue().Set(static_cast<int32_t>(install_id));
 100 }
 101
 102 // static
 103 bool WebstoreBindings::GetWebstoreItemIdFromFrame(
 104       WebFrame* frame, const std::string& preferred_store_link_url,
 105       std::string* webstore_item_id, std::string* error) {
 106   if (frame != frame->top()) {
 107     *error = kNotInTopFrameError;
 108     return false;
 109   }
 110
 111   if (!WebUserGestureIndicator::isProcessingUserGesture()) {
 112     *error = kNotUserGestureError;
 113     return false;
 114   }
 115
 116   WebDocument document = frame->document();
 117   if (document.isNull()) {
 118     *error = kNoWebstoreItemLinkFoundError;
 119     return false;
 120   }
 121
 122   WebElement head = document.head();
 123   if (head.isNull()) {
 124     *error = kNoWebstoreItemLinkFoundError;
 125     return false;
 126   }
 127
 128   GURL webstore_base_url =
 129       GURL(extension_urls::GetWebstoreItemDetailURLPrefix());
 130   WebNodeList children = head.childNodes();
 131   for (unsigned i = 0; i < children.length(); ++i) {
 132     WebNode child = children.item(i);
 133     if (!child.isElementNode())
 134       continue;
 135     WebElement elem = child.to<WebElement>();
 136
 137     if (!elem.hasTagName("link") || !elem.hasAttribute("rel") ||
 138         !elem.hasAttribute("href"))
 139       continue;
 140
 141     std::string rel = elem.getAttribute("rel").utf8();
 142     if (!LowerCaseEqualsASCII(rel, kWebstoreLinkRelation))
 143       continue;
 144
 145     std::string webstore_url_string(elem.getAttribute("href").utf8());
 146
 147     if (!preferred_store_link_url.empty() &&
 148         preferred_store_link_url != webstore_url_string) {
 149       continue;
 150     }
 151
 152     GURL webstore_url = GURL(webstore_url_string);
 153     if (!webstore_url.is_valid()) {
 154       *error = kInvalidWebstoreItemUrlError;
 155       return false;
 156     }
 157
 158     if (webstore_url.scheme() != webstore_base_url.scheme() ||
 159         webstore_url.host() != webstore_base_url.host() ||
 160         !StartsWithASCII(
 161             webstore_url.path(), webstore_base_url.path(), true)) {
 162       *error = kInvalidWebstoreItemUrlError;
 163       return false;
 164     }
 165
 166     std::string candidate_webstore_item_id = webstore_url.path().substr(
 167         webstore_base_url.path().length());
 168     if (!extensions::Extension::IdIsValid(candidate_webstore_item_id)) {
 169       *error = kInvalidWebstoreItemUrlError;
 170       return false;
 171     }
 172
 173     std::string reconstructed_webstore_item_url_string =
 174         extension_urls::GetWebstoreItemDetailURLPrefix() +
 175             candidate_webstore_item_id;
 176     if (reconstructed_webstore_item_url_string != webstore_url_string) {
 177       *error = kInvalidWebstoreItemUrlError;
 178       return false;
 179     }
 180
 181     *webstore_item_id = candidate_webstore_item_id;
 182     return true;
 183   }
 184
 185   *error = kNoWebstoreItemLinkFoundError;
 186   return false;
 187 }
 188
 189 bool WebstoreBindings::OnMessageReceived(const IPC::Message& message) {
 190   IPC_BEGIN_MESSAGE_MAP(WebstoreBindings, message)
 191     IPC_MESSAGE_HANDLER(ExtensionMsg_InlineWebstoreInstallResponse,
 192                         OnInlineWebstoreInstallResponse)
 193     IPC_MESSAGE_HANDLER(ExtensionMsg_InlineInstallStageChanged,
 194                         OnInlineInstallStageChanged)
 195     IPC_MESSAGE_HANDLER(ExtensionMsg_InlineInstallDownloadProgress,
 196                         OnInlineInstallDownloadProgress)
 197     IPC_MESSAGE_UNHANDLED(CHECK(false) << "Unhandled IPC message")
 198   IPC_END_MESSAGE_MAP()
 199   return true;
 200 }
 201
 202 void WebstoreBindings::OnInlineWebstoreInstallResponse(
 203     int install_id,
 204     bool success,
 205     const std::string& error) {
 206   v8::Isolate* isolate = context()->isolate();
 207   v8::HandleScope handle_scope(isolate);
 208   v8::Context::Scope context_scope(context()->v8_context());
 209   v8::Handle<v8::Value> argv[] = {
 210     v8::Integer::New(isolate, install_id),
 211     v8::Boolean::New(isolate, success),
 212     v8::String::NewFromUtf8(isolate, error.c_str())
 213   };
 214   context()->module_system()->CallModuleMethod(
 215       "webstore", "onInstallResponse", arraysize(argv), argv);
 216 }
 217
 218 void WebstoreBindings::OnInlineInstallStageChanged(int stage) {
 219   const char* stage_string = NULL;
 220   api::webstore::InstallStage install_stage =
 221       static_cast<api::webstore::InstallStage>(stage);
 222   switch (install_stage) {
 223     case api::webstore::INSTALL_STAGE_DOWNLOADING:
 224       stage_string = api::webstore::kInstallStageDownloading;
 225       break;
 226     case api::webstore::INSTALL_STAGE_INSTALLING:
 227       stage_string = api::webstore::kInstallStageInstalling;
 228       break;
 229   }
 230   v8::Isolate* isolate = context()->isolate();
 231   v8::HandleScope handle_scope(isolate);
 232   v8::Context::Scope context_scope(context()->v8_context());
 233   v8::Handle<v8::Value> argv[] = {
 234       v8::String::NewFromUtf8(isolate, stage_string)};
 235   context()->module_system()->CallModuleMethod(
 236       "webstore", "onInstallStageChanged", arraysize(argv), argv);
 237 }
 238
 239 void WebstoreBindings::OnInlineInstallDownloadProgress(int percent_downloaded) {
 240   v8::Isolate* isolate = context()->isolate();
 241   v8::HandleScope handle_scope(isolate);
 242   v8::Context::Scope context_scope(context()->v8_context());
 243   v8::Handle<v8::Value> argv[] = {
 244       v8::Number::New(isolate, percent_downloaded / 100.0)};
 245   context()->module_system()->CallModuleMethod(
 246       "webstore", "onDownloadProgress", arraysize(argv), argv);
 247 }
 248
 249 }  // namespace extensions