Relanding: Add js api for hosted/packaged apps to request notification authorization

chrome/renderer/extensions/chrome_webstore_bindings.cc

 // Copyright (c) 2011 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/chrome_webstore_bindings.h"
 
 #include "base/lazy_instance.h"
 #include "base/string_util.h"
 #include "chrome/common/extensions/extension.h"
 #include "chrome/renderer/extensions/extension_helper.h"
+#include "chrome/renderer/weak_v8_function_map.h"
 #include "content/renderer/render_view.h"
 #include "googleurl/src/gurl.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebDocument.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebElement.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebFrame.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebNode.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebNodeList.h"
 #include "v8/include/v8.h"
 
 using WebKit::WebDocument;
@@ skipping 21 matching lines @@
 const char kNoWebstoreItemLinkFoundError[] =
     "No Chrome Web Store item link found.";
 const char kInvalidWebstoreItemUrlError[] =
     "Invalid Chrome Web Store item URL.";
 
 // 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 HandleInstallResponse.
 int g_next_install_id = 0;
 
-// Callbacks are kept track of in maps keyed by install ID. Values are weak
-// references to functions. Entries are automatically removed when functions
-// get garbage collected.
-typedef std::map<int, v8::Persistent<v8::Function> > CallbackMap;
-
-base::LazyInstance<CallbackMap> g_success_callbacks(base::LINKER_INITIALIZED);
-base::LazyInstance<CallbackMap> g_failure_callbacks(base::LINKER_INITIALIZED);
-
-// Extra data to be passed to MakeWeak/RemoveFromCallbackMap to know which entry
-// to remove from which map.
-struct CallbackMapData {
-  CallbackMap* callback_map;
-  int install_id;
-};
-
-// Disposes of a callback function and its corresponding entry in the callback
-// map.
-static void RemoveFromCallbackMap(v8::Persistent<v8::Value> context,
-                                  void* data) {
-  CallbackMapData* callback_map_data = static_cast<CallbackMapData*>(data);
-  callback_map_data->callback_map->erase(callback_map_data->install_id);
-  delete callback_map_data;
-  context.Dispose();
-}
-
-// Adds |callback_param| (assumed to be a function) to |callback_map| under the
-// |install_id| key. Will be removed from the map when the value is about to be
-// GCed.
-static void AddToCallbackMap(int install_id,
-                             v8::Local<v8::Value> callback_param,
-                             CallbackMap* callback_map) {
-  CHECK(callback_param->IsFunction());
-  CallbackMapData* callback_map_data = new CallbackMapData();
-  callback_map_data->install_id = install_id;
-  callback_map_data->callback_map = callback_map;
-
-  v8::Local<v8::Function> function = v8::Function::Cast(*callback_param);
-  v8::Persistent<v8::Function> wrapper =
-      v8::Persistent<v8::Function>::New(function);
-  (*callback_map)[install_id] = wrapper;
-  wrapper.MakeWeak(callback_map_data, RemoveFromCallbackMap);
-}
+base::LazyInstance<WeakV8FunctionMap> g_success_callbacks(
+    base::LINKER_INITIALIZED);
+base::LazyInstance<WeakV8FunctionMap> g_failure_callbacks(
+    base::LINKER_INITIALIZED);
 
 } // anonymous namespace
 
 class ExtensionImpl : public v8::Extension {
  public:
   ExtensionImpl() :
     v8::Extension(
         kWebstoreV8ExtensionName,
         "var chrome = chrome || {};"
         "if (!chrome.webstore) {"
@@ skipping 36 matching lines @@
     std::string error;
     if (!GetWebstoreItemIdFromFrame(
         frame, preferred_store_link_url, &webstore_item_id, &error)) {
       v8::ThrowException(v8::String::New(error.c_str()));
       return v8::Undefined();
     }
 
     int install_id = g_next_install_id++;
     if (args.Length() >= 2 && !args[1]->IsUndefined()) {
       if (args[1]->IsFunction()) {
-        AddToCallbackMap(install_id, args[1], g_success_callbacks.Pointer());
+        g_success_callbacks.Get().Add(install_id, v8::Function::Cast(*args[1]));
       } else {
         v8::ThrowException(v8::String::New(kSuccessCallbackNotAFunctionError));
         return v8::Undefined();
       }
     }
     if (args.Length() >= 3 && !args[2]->IsUndefined()) {
       if (args[2]->IsFunction()) {
-        AddToCallbackMap(install_id, args[2], g_failure_callbacks.Pointer());
+        g_failure_callbacks.Get().Add(install_id, v8::Function::Cast(*args[2]));
       } else {
         v8::ThrowException(v8::String::New(kFailureCallbackNotAFunctionError));
         return v8::Undefined();
       }
     }
 
     ExtensionHelper* helper = ExtensionHelper::Get(render_view);
     helper->InlineWebstoreInstall(
         install_id, webstore_item_id, frame->document().url());
     return v8::Undefined();
@@ skipping 94 matching lines @@
 
 // static
 v8::Extension* ChromeWebstoreExtension::Get() {
   return new ExtensionImpl();
 }
 
 // static
 void ChromeWebstoreExtension::HandleInstallResponse(int install_id,
                                                     bool success,
                                                     const std::string& error) {
-  CallbackMap* callback_map =
-      success ? g_success_callbacks.Pointer() : g_failure_callbacks.Pointer();
-  CallbackMap::iterator iter = callback_map->find(install_id);
+  WeakV8FunctionMap& callback_map =
+      success ? g_success_callbacks.Get() : g_failure_callbacks.Get();
 
-  if (iter == callback_map->end() || iter->second.IsEmpty()) return;
-  const v8::Persistent<v8::Function>& function = (*iter).second;
+  v8::Persistent<v8::Function> function = callback_map.Remove(install_id);
+  if (function.IsEmpty())
+    return;
 
   v8::HandleScope handle_scope;
   v8::Context::Scope context_scope(function->CreationContext());
   v8::Handle<v8::Value> argv[1];
   argv[0] = v8::String::New(error.c_str());
   function->Call(v8::Object::New(), arraysize(argv), argv);
-
-  callback_map->erase(iter);
 }