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

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

+// 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
+
+struct WebstoreAPI::ObservedInstallInfo {
+  ObservedInstallInfo(int routing_id,
+                      const std::string& extension_id,
+                      IPC::Sender* ipc_sender);
+  ~ObservedInstallInfo();
+
+  int routing_id;
+  std::string extension_id;
+  IPC::Sender* ipc_sender;
+};
+
+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),
+      install_observer_(this) {
+  install_observer_.Add(InstallTrackerFactory::GetForProfile(
+      Profile::FromBrowserContext(browser_context)));
+}
+
+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));
+    }
+  }
+}
+
+void WebstoreAPI::OnBeginCrxInstall(const std::string& extension_id) {
+  SendInstallMessageIfObserved(extension_id,
+                               api::webstore::kInstallStageInstalling);
+}
+
+void WebstoreAPI::OnShutdown() {
+  install_observer_.Remove(InstallTrackerFactory::GetForProfile(

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

Is it okay to fetch a BCKS while it's being Shutdown() in order to remove an
observer?  Or do we need to keep track of the tracker while we observe it?

[asargent_no_longer_on_chrome, 2014/03/03 22:25:33]

I think so. From
components/browser_context_keyed_service/browser_context_keyed_service.h:

"
// Many services that hang off BrowserContext have a two-pass shutdown. Many
// subsystems need a first pass shutdown phase where they drop references. Not
// all services will need this, so there's a default implementation. Only once
// every system has been given a chance to drop references do we start deleting
// objects.

"


BTW, another approach you might consider: just hold the install_observer_ inside
a scoped_ptr, and here instead of explicitly calling Remove with a Profile* that
you look up, just clear the scoped_ptr causing ~ScopedObserver() to run and
clean these up automatically. 

[Devlin, 2014/03/03 22:49:16]

Yep, that was my contingency plan :)  And actually, I think it does make it
almost look cleaner - I just wish it would get rid of the include in the .h. 
But, at least it saves a lookup for the BCKS.

+      Profile::FromBrowserContext(browser_context_)));
+}
+
+void WebstoreAPI::Shutdown() {}
+
+// static
+ProfileKeyedAPIFactory<WebstoreAPI>* WebstoreAPI::GetFactoryInstance() {
+  return g_factory.Pointer();
+}
+
+void WebstoreAPI::SendInstallMessageIfObserved(
+    const std::string& extension_id,
+    const char* install_stage) {
+  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