Add chrome.webstore API methods to allow sites to see progress of installation

chrome/renderer/extensions/webstore_bindings.cc

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "chrome/renderer/extensions/webstore_bindings.h"
 
 #include "base/strings/string_util.h"
+#include "chrome/common/extensions/api/webstore/webstore_api_constants.h"
 #include "chrome/common/extensions/extension_constants.h"
 #include "chrome/common/extensions/extension_messages.h"
 #include "chrome/renderer/extensions/chrome_v8_context.h"
 #include "content/public/renderer/render_view.h"
 #include "extensions/common/extension.h"
 #include "grit/renderer_resources.h"
 #include "third_party/WebKit/public/web/WebDocument.h"
 #include "third_party/WebKit/public/web/WebElement.h"
 #include "third_party/WebKit/public/web/WebNode.h"
 #include "third_party/WebKit/public/web/WebNodeList.h"
@@ skipping 21 matching lines @@
 const char kFailureCallbackNotAFunctionError[] =
     "The failure callback parameter must be a function.";
 const char kNotInTopFrameError[] =
     "Chrome Web Store installations can only be started by the top frame.";
 const char kNotUserGestureError[] =
     "Chrome Web Store installations can only be initated by a user gesture.";
 const char kNoWebstoreItemLinkFoundError[] =
     "No Chrome Web Store item link found.";
 const char kInvalidWebstoreItemUrlError[] =
     "Invalid Chrome Web Store item URL.";
+const char kInstallStageListenerCallbackNotAFunctionError[] =
+    "The listener callback for install stage change must be a function.";
+const char kDownloadProgressListenerCallbackNotAFunctionError[] =
+    "The listener callback for download progress must be a function.";

[not at google - send to devlin, 2014/02/27 21:49:56]

these sort of checks can be handled by the Event object when you use that

[Devlin, 2014/02/28 18:04:51]

Done.

 
 // chrome.webstore.install() calls generate an install ID so that the install's
 // callbacks may be fired when the browser notifies us of install completion
 // (successful or not) via OnInlineWebstoreInstallResponse.
 int g_next_install_id = 0;
 
+// Parses the given |args| to determine if a valid listener function argument
+// was passed. NULL is considered valid, since it is used to unset the current
+// listener.
+// Returns true on success, false on failure. If successful,
+// populates |is_listener_set| with whether or not the listener should be set.
+bool GetIsListenerSet(const v8::FunctionCallbackInfo<v8::Value>& args,
+                      bool* is_listener_set) {
+  if (args[0]->IsNull()) {
+    *is_listener_set = false;
+    return true;
+  }
+
+  if (args[0]->IsFunction()) {
+    *is_listener_set = true;
+    return true;
+  }
+
+  return false;
+}
+
 } // anonymous namespace
 
 WebstoreBindings::WebstoreBindings(Dispatcher* dispatcher,
                                    ChromeV8Context* context)
     : ChromeV8Extension(dispatcher, context),
       ChromeV8ExtensionHandler(context) {
   RouteFunction("Install",
                 base::Bind(&WebstoreBindings::Install, base::Unretained(this)));
+  RouteFunction("ValidateInstallStageListener",
+                base::Bind(&WebstoreBindings::ValidateInstallStageListener,
+                           base::Unretained(this)));
+  RouteFunction("ValidateDownloadProgressListener",
+                base::Bind(&WebstoreBindings::ValidateDownloadProgressListener,
+                           base::Unretained(this)));
+}
+
+content::RenderView* WebstoreBindings::GetRenderView() {
+  WebFrame* frame = WebFrame::frameForContext(context()->v8_context());
+  if (!frame || !frame->view())
+    return NULL;
+  content::RenderView* render_view =
+      content::RenderView::FromWebView(frame->view());
+  return render_view;

[not at google - send to devlin, 2014/02/27 21:49:56]

https://code.google.com/p/chromium/codesearch#chromium/src/chrome/renderer/ex...

https://code.google.com/p/chromium/codesearch#chromium/src/chrome/renderer/ex...

[Devlin, 2014/02/28 18:04:51]

Done.

 }
 
 void WebstoreBindings::Install(
     const v8::FunctionCallbackInfo<v8::Value>& args) {
-  WebFrame* frame = WebFrame::frameForContext(context()->v8_context());
-  if (!frame || !frame->view())
-    return;
-
-  content::RenderView* render_view =
-      content::RenderView::FromWebView(frame->view());
+  content::RenderView* render_view = GetRenderView();
   if (!render_view)
     return;
 
+  // The first two arguments, which indicate whether or not there are install
+  // stage and download progress listeners, are provided directly by the
+  // custom bindings, so should always be valid.
+  int listener_mask = 0;
+  if (args[0]->IsBoolean()) {

[not at google - send to devlin, 2014/02/27 21:49:56]

so - *you* are calling the Install method. Rather than dealing with bad input
from yourself, just CHECK here and do validation in JS if necessary.

(yes this whole method is broken in that way; we should fix that, it's
unnecessarily complicated)

[Devlin, 2014/02/28 18:04:51]

Done!

+    if (args[0]->BooleanValue())
+      listener_mask |= api::webstore::INSTALL_STAGE_LISTENER;
+  } else {
+    NOTREACHED();
+    return;
+  }
+  if (args[1]->IsBoolean()) {
+    if (args[1]->BooleanValue())
+      listener_mask |= api::webstore::DOWNLOAD_PROGRESS_LISTENER;
+  } else {
+    NOTREACHED();
+    return;
+  }
+
   std::string preferred_store_link_url;
-  if (!args[0]->IsUndefined()) {
-    if (args[0]->IsString()) {
-      preferred_store_link_url = std::string(*v8::String::Utf8Value(args[0]));
+  if (!args[2]->IsUndefined()) {
+    if (args[2]->IsString()) {
+      preferred_store_link_url = std::string(*v8::String::Utf8Value(args[2]));
     } else {
       args.GetIsolate()->ThrowException(v8::String::NewFromUtf8(
           args.GetIsolate(), kPreferredStoreLinkUrlNotAString));
       return;
     }
   }
 
   std::string webstore_item_id;
   std::string error;
+  WebFrame* frame = WebFrame::frameForContext(context()->v8_context());
+
   if (!GetWebstoreItemIdFromFrame(
       frame, preferred_store_link_url, &webstore_item_id, &error)) {
     args.GetIsolate()->ThrowException(
         v8::String::NewFromUtf8(args.GetIsolate(), error.c_str()));
     return;
   }
 
   int install_id = g_next_install_id++;
-  if (!args[1]->IsUndefined() && !args[1]->IsFunction()) {
+  if (!args[3]->IsUndefined() && !args[3]->IsFunction()) {
     args.GetIsolate()->ThrowException(v8::String::NewFromUtf8(
         args.GetIsolate(), kSuccessCallbackNotAFunctionError));
     return;
   }
 
-  if (!args[2]->IsUndefined() && !args[2]->IsFunction()) {
+  if (!args[4]->IsUndefined() && !args[4]->IsFunction()) {
     args.GetIsolate()->ThrowException(v8::String::NewFromUtf8(
         args.GetIsolate(), kFailureCallbackNotAFunctionError));
     return;
   }
 
-  Send(new ExtensionHostMsg_InlineWebstoreInstall(
-      render_view->GetRoutingID(),
-      install_id,
-      GetRoutingID(),
-      webstore_item_id,
-      frame->document().url()));
+  Send(new ExtensionHostMsg_InlineWebstoreInstall(render_view->GetRoutingID(),
+                                                  install_id,
+                                                  GetRoutingID(),
+                                                  webstore_item_id,
+                                                  frame->document().url(),
+                                                  listener_mask));
 
   args.GetReturnValue().Set(static_cast<int32_t>(install_id));
 }
 
+void WebstoreBindings::ValidateInstallStageListener(
+    const v8::FunctionCallbackInfo<v8::Value>& args) {
+  content::RenderView* render_view = GetRenderView();
+  if (!render_view)
+    return;
+
+  bool is_listener_set = false;
+  if (!GetIsListenerSet(args, &is_listener_set)) {
+    args.GetIsolate()->ThrowException(v8::String::NewFromUtf8(
+        args.GetIsolate(), kInstallStageListenerCallbackNotAFunctionError));
+    args.GetReturnValue().Set(false);
+  }
+  args.GetReturnValue().Set(true);
+}
+
+void WebstoreBindings::ValidateDownloadProgressListener(
+    const v8::FunctionCallbackInfo<v8::Value>& args) {
+  content::RenderView* render_view = GetRenderView();
+  if (!render_view)
+    return;
+
+  bool is_listener_set = false;
+  if (!GetIsListenerSet(args, &is_listener_set)) {
+    args.GetIsolate()->ThrowException(v8::String::NewFromUtf8(
+        args.GetIsolate(), kDownloadProgressListenerCallbackNotAFunctionError));
+    args.GetReturnValue().Set(false);
+  }
+  args.GetReturnValue().Set(true);
+}
+
 // static
 bool WebstoreBindings::GetWebstoreItemIdFromFrame(
       WebFrame* frame, const std::string& preferred_store_link_url,
       std::string* webstore_item_id, std::string* error) {
   if (frame != frame->top()) {
     *error = kNotInTopFrameError;
     return false;
   }
 
   if (!WebUserGestureIndicator::isProcessingUserGesture()) {
@@ skipping 71 matching lines @@
   }
 
   *error = kNoWebstoreItemLinkFoundError;
   return false;
 }
 
 bool WebstoreBindings::OnMessageReceived(const IPC::Message& message) {
   IPC_BEGIN_MESSAGE_MAP(WebstoreBindings, message)
     IPC_MESSAGE_HANDLER(ExtensionMsg_InlineWebstoreInstallResponse,
                         OnInlineWebstoreInstallResponse)
+    IPC_MESSAGE_HANDLER(ExtensionMsg_InlineInstallStageChanged,
+                        OnInlineInstallStageChanged)
+    IPC_MESSAGE_HANDLER(ExtensionMsg_InlineInstallDownloadProgress,
+                        OnInlineInstallDownloadProgress)
     IPC_MESSAGE_UNHANDLED(CHECK(false) << "Unhandled IPC message")
   IPC_END_MESSAGE_MAP()
   return true;
 }
 
 void WebstoreBindings::OnInlineWebstoreInstallResponse(
     int install_id,
     bool success,
     const std::string& error) {
   v8::Isolate* isolate = context()->isolate();
   v8::HandleScope handle_scope(isolate);
   v8::Context::Scope context_scope(context()->v8_context());
   v8::Handle<v8::Value> argv[] = {
     v8::Integer::New(isolate, install_id),
     v8::Boolean::New(isolate, success),
     v8::String::NewFromUtf8(isolate, error.c_str())
   };
   context()->module_system()->CallModuleMethod(
       "webstore", "onInstallResponse", arraysize(argv), argv);
 }
 
+void WebstoreBindings::OnInlineInstallStageChanged(const std::string& stage) {
+  v8::Isolate* isolate = context()->isolate();
+  v8::HandleScope handle_scope(isolate);
+  v8::Context::Scope context_scope(context()->v8_context());
+  v8::Handle<v8::Value> argv[] = {
+      v8::String::NewFromUtf8(isolate, stage.c_str())};
+  context()->module_system()->CallModuleMethod(
+      "webstore", "onInstallStageChanged", arraysize(argv), argv);
+}
+
+void WebstoreBindings::OnInlineInstallDownloadProgress(int percent_downloaded) {
+  v8::Isolate* isolate = context()->isolate();
+  v8::HandleScope handle_scope(isolate);
+  v8::Context::Scope context_scope(context()->v8_context());
+  v8::Handle<v8::Value> argv[] = {
+      v8::Number::New(isolate, percent_downloaded / 100.0)};
+  context()->module_system()->CallModuleMethod(
+      "webstore", "onDownloadProgress", arraysize(argv), argv);
+}
+
 }  // namespace extensions