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

chrome/browser/extensions/api/webstore/webstore_api.cc

Index: chrome/browser/extensions/api/webstore/webstore_api.cc
diff --git a/chrome/browser/extensions/api/webstore/webstore_api.cc b/chrome/browser/extensions/api/webstore/webstore_api.cc
new file mode 100644
index 0000000000000000000000000000000000000000..a50b271838ef50472472e65291f1f3b69bb43bbc
--- /dev/null
+++ b/chrome/browser/extensions/api/webstore/webstore_api.cc
@@ -0,0 +1,129 @@
+// Copyright 2014 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/browser/extensions/api/webstore/webstore_api.h"
+
+#include "base/lazy_instance.h"
+#include "base/values.h"
+#include "chrome/browser/extensions/install_tracker.h"
+#include "chrome/browser/extensions/install_tracker_factory.h"
+#include "chrome/browser/profiles/profile.h"
+#include "chrome/common/extensions/api/webstore/webstore_api_constants.h"
+#include "chrome/common/extensions/extension_messages.h"
+#include "extensions/browser/extension_system.h"
+#include "ipc/ipc_sender.h"
+
+namespace extensions {
+
+namespace {
+
+base::LazyInstance<ProfileKeyedAPIFactory<WebstoreAPI> > g_factory =
+    LAZY_INSTANCE_INITIALIZER;
+
+}  // namespace
+
+WebstoreAPI::ObservedInstallInfo::ObservedInstallInfo(
+    int routing_id,
+    const std::string& extension_id,
+    IPC::Sender* ipc_sender)
+    : routing_id(routing_id),
+      extension_id(extension_id),
+      ipc_sender(ipc_sender) {}
+
+WebstoreAPI::ObservedInstallInfo::~ObservedInstallInfo() {}
+
+WebstoreAPI::WebstoreAPI(content::BrowserContext* browser_context)
+    : browser_context_(browser_context) {
+  InstallTrackerFactory::GetForProfile(
+      Profile::FromBrowserContext(browser_context))->AddObserver(this);

[asargent_no_longer_on_chrome, 2014/03/03 18:49:08]

Should you be removing yourself as an observer in the destructor?

(Perhaps you could take advantage of base/scoped_observer.h)

[Devlin, 2014/03/03 21:15:13]

Done, but see related comment.

+}
+
+WebstoreAPI::~WebstoreAPI() {}
+
+// static
+WebstoreAPI* WebstoreAPI::Get(content::BrowserContext* browser_context) {
+  return ProfileKeyedAPIFactory<WebstoreAPI>::GetForProfile(browser_context);
+}
+
+void WebstoreAPI::OnInlineInstallStart(int routing_id,
+                                       IPC::Sender* ipc_sender,
+                                       const std::string& extension_id,
+                                       int listeners_mask) {
+  if (listeners_mask & api::webstore::INSTALL_STAGE_LISTENER) {
+    install_stage_listeners_.push_back(
+        ObservedInstallInfo(routing_id, extension_id, ipc_sender));
+  }
+
+  if (listeners_mask & api::webstore::DOWNLOAD_PROGRESS_LISTENER) {
+    download_progress_listeners_.push_back(
+        ObservedInstallInfo(routing_id, extension_id, ipc_sender));
+  }
+}
+
+void WebstoreAPI::OnInlineInstallFinished(int routing_id,
+                                          const std::string& extension_id) {
+  RemoveListeners(routing_id, extension_id, &download_progress_listeners_);
+  RemoveListeners(routing_id, extension_id, &install_stage_listeners_);
+}
+
+void WebstoreAPI::OnBeginExtensionDownload(const std::string& extension_id) {
+  SendInstallMessageIfObserved(extension_id,
+                               api::webstore::kInstallStageDownloading);
+}
+
+void WebstoreAPI::OnDownloadProgress(const std::string& extension_id,
+                                     int percent_downloaded) {
+  for (ObservedInstallInfoList::const_iterator iter =
+           download_progress_listeners_.begin();
+       iter != download_progress_listeners_.end();
+       ++iter) {
+    if (iter->extension_id == extension_id) {
+      iter->ipc_sender->Send(new ExtensionMsg_InlineInstallDownloadProgress(
+          iter->routing_id, percent_downloaded));

[not at google - send to devlin, 2014/03/01 01:42:07]

you could actually save yourself the trouble of adding these new extension
messages, and the boilerplate handling on the renderer, and do:

ListValue args;
args.AppendDouble(percent_downloaded / 100.0);
iter->ipc_sender->Send(new ExtensionMsg_MessageInvoke(
    iter->rounting_id, "", "webstore", "onDownloadProgress", args, false));

same for the other message.

Reference:
https://code.google.com/p/chromium/codesearch#chromium/src/chrome/common/exte...

[Devlin, 2014/03/03 17:44:59]

Yes and no.

We can't just do ExtensionMsg_MessageInvoke because that's only handled by the
Dispatcher and ExtensionHelper (which forwards it to the Dispatcher).  From the
Dispatcher, it's sent off to every tab, so if multiple tabs had listeners, we'd
erroneously send the message to them, too (versus now, where we only send the
message to the tab that initiated the installation).

We could, though, choose to handle ExtensionMsg_MessageInvoke within
WebstoreBindings, since in both of the calls, all we do is forward the message.
This lets us only implement one new handler in WebstoreBindings and not add any
new ExtensionMessages.  But it has the disadvantage of then _allowing_ people to
send MessageInvokes to Bindings mistakenly, and we won't get an IPC Unhandled
error (in Dispatcher, we don't worry because we basically handle any invoke
correctly).

Preferences? (and sorry if what you meant from the start was to use
MessageInvoke and handle it explicitly in WebstoreBindings...just wanna make
sure)

[Devlin, 2014/03/03 21:15:13]

(Talked about this offline and decided that going with the current approach was
best. Using MessageInvoke resulted in more complexity than it saved.)

+    }
+  }
+}
+
+void WebstoreAPI::OnBeginCrxInstall(const std::string& extension_id) {
+  SendInstallMessageIfObserved(extension_id,
+                               api::webstore::kInstallStageInstalling);
+}
+
+void WebstoreAPI::Shutdown() {
+  InstallTrackerFactory::GetForProfile(
+      Profile::FromBrowserContext(browser_context_))->RemoveObserver(this);
+}
+
+// static
+ProfileKeyedAPIFactory<WebstoreAPI>* WebstoreAPI::GetFactoryInstance() {
+  return g_factory.Pointer();
+}
+
+void WebstoreAPI::SendInstallMessageIfObserved(
+    const std::string& extension_id,
+    const std::string& install_stage) {

[asargent_no_longer_on_chrome, 2014/03/03 18:49:08]

Looks like this only gets called with const char*, would it make sense to change
the parameter type to that? (Not sure off the top of my head if the compiler can
already arrange to avoid constructing 2 std::string's the way you have it -
maybe ask jyasskin who I'm sure could tell you)

[Devlin, 2014/03/03 21:15:13]

Done.

+  for (ObservedInstallInfoList::const_iterator iter =
+           install_stage_listeners_.begin();
+       iter != install_stage_listeners_.end();
+       ++iter) {
+    if (iter->extension_id == extension_id) {
+      iter->ipc_sender->Send(new ExtensionMsg_InlineInstallStageChanged(
+          iter->routing_id, install_stage));
+    }
+  }
+}
+
+void WebstoreAPI::RemoveListeners(int routing_id,
+                                  const std::string& extension_id,
+                                  ObservedInstallInfoList* listeners) {
+  for (ObservedInstallInfoList::iterator iter = listeners->begin();
+       iter != listeners->end();) {
+    if (iter->extension_id == extension_id && iter->routing_id == routing_id)
+      iter = listeners->erase(iter);
+    else
+      ++iter;
+  }
+}
+
+}  // namespace extensions