Implement extension specific events

chrome/renderer/extensions/extension_process_bindings.cc

 // Copyright (c) 2009 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/extension_process_bindings.h"
 
 #include "base/singleton.h"
 #include "chrome/common/render_messages.h"
 #include "chrome/common/url_constants.h"
 #include "chrome/renderer/extensions/bindings_utils.h"
 #include "chrome/renderer/extensions/event_bindings.h"
 #include "chrome/renderer/extensions/renderer_extension_bindings.h"
 #include "chrome/renderer/js_only_v8_extensions.h"
 #include "chrome/renderer/render_view.h"
 #include "grit/renderer_resources.h"
 #include "webkit/glue/webframe.h"
 
 using bindings_utils::GetStringResource;
 using bindings_utils::ContextInfo;
 using bindings_utils::ContextList;
 using bindings_utils::GetContexts;
 using bindings_utils::GetPendingRequestMap;
 using bindings_utils::PendingRequest;
 using bindings_utils::ExtensionBase;
 
 namespace {
 
+// A map of extension ID to vector of page action ids.
+typedef std::map< std::string, std::vector<std::string> > PageActionIdMap;
+
 const char kExtensionName[] = "chrome/ExtensionProcessBindings";
 const char* kExtensionDeps[] = {
   BaseJsV8Extension::kName,
   EventBindings::kName,
   JsonSchemaJsV8Extension::kName,
   RendererExtensionBindings::kName,
 };
 
 struct SingletonData {
   std::set<std::string> function_names_;
+  PageActionIdMap page_action_ids_;
 };
 
 static std::set<std::string>* GetFunctionNameSet() {
   return &Singleton<SingletonData>()->function_names_;
 }
 
+static PageActionIdMap* GetPageActionMap() {
+  return &Singleton<SingletonData>()->page_action_ids_;
+}
+
 class ExtensionImpl : public ExtensionBase {
  public:
   ExtensionImpl() : ExtensionBase(
       kExtensionName, GetStringResource<IDR_EXTENSION_PROCESS_BINDINGS_JS>(),
       arraysize(kExtensionDeps), kExtensionDeps) {}
 
   static void SetFunctionNames(const std::vector<std::string>& names) {
     std::set<std::string>* name_set = GetFunctionNameSet();
     for (size_t i = 0; i < names.size(); ++i) {
       name_set->insert(names[i]);
     }
   }
 
   virtual v8::Handle<v8::FunctionTemplate> GetNativeFunction(
       v8::Handle<v8::String> name) {
     std::set<std::string>* names = GetFunctionNameSet();
 
     if (name->Equals(v8::String::New("GetViews"))) {
       return v8::FunctionTemplate::New(GetViews);
     } else if (name->Equals(v8::String::New("GetNextRequestId"))) {
       return v8::FunctionTemplate::New(GetNextRequestId);
+    } else if (name->Equals(v8::String::New("GetCurrentPageActions"))) {
+      return v8::FunctionTemplate::New(GetCurrentPageActions);
     } else if (names->find(*v8::String::AsciiValue(name)) != names->end()) {
       return v8::FunctionTemplate::New(StartRequest, name);
     }
 
     return ExtensionBase::GetNativeFunction(name);
   }
 
  private:
-  static v8::Handle<v8::Value> GetViews(const v8::Arguments& args) {
+  static std::string ExtensionIdFromCurrentContext() {
     RenderView* renderview = bindings_utils::GetRenderViewForCurrentContext();
     DCHECK(renderview);
     GURL url = renderview->webview()->GetMainFrame()->GetURL();
-    std::string extension_id = url.host();
+    return url.host();
+  }
+
+  static v8::Handle<v8::Value> GetViews(const v8::Arguments& args) {
+    std::string extension_id = ExtensionIdFromCurrentContext();
 
     ContextList contexts =
         bindings_utils::GetContextsForExtension(extension_id);
     DCHECK(contexts.size() > 0);
 
     v8::Local<v8::Array> views = v8::Array::New(contexts.size());
     int index = 0;
     ContextList::const_iterator it = contexts.begin();
     for (; it != contexts.end(); ++it) {
       v8::Local<v8::Value> window = (*it)->context->Global()->Get(
           v8::String::New("window"));
       DCHECK(!window.IsEmpty());
       views->Set(v8::Integer::New(index), window);
       index++;
     }
     return views;
   }
 
   static v8::Handle<v8::Value> GetNextRequestId(const v8::Arguments& args) {
     static int next_request_id = 0;
     return v8::Integer::New(next_request_id++);
   }
-  
+
+  static v8::Handle<v8::Value> GetCurrentPageActions(
+      const v8::Arguments& args) {
+    std::string extension_id = ExtensionIdFromCurrentContext();
+    PageActionIdMap* page_action_map =
+        GetPageActionMap();

[Matt Perry, 2009/07/14 21:17:48]

nit: no need to wrap this

+    PageActionIdMap::const_iterator it =
+        page_action_map->find(extension_id);
+
+    std::vector<std::string> page_actions;

[Matt Perry, 2009/07/14 21:17:48]

This creates a copy of the vector.  Use a pointer a pointer instead.

+    size_t size  = 0;
+    if (it != page_action_map->end()) {
+      page_actions = it->second;
+      size = page_actions.size();
+    }
+
+    v8::Local<v8::Array> page_action_vector = v8::Array::New(size);

[Matt Perry, 2009/07/14 21:17:48]

nit: "vector" is lying - it's an array

+    for (size_t i = 0; i < size; ++i) {
+      std::string page_action_id = page_actions[i];

[Matt Perry, 2009/07/14 21:17:48]

nit: wasteful copy. use const ref

+      page_action_vector->Set(v8::Integer::New(i),
+                              v8::String::New(page_action_id.c_str()));
+    }
+
+    return page_action_vector;
+  }
+
   // Starts an API request to the browser, with an optional callback.  The
   // callback will be dispatched to EventBindings::HandleResponse.
   static v8::Handle<v8::Value> StartRequest(const v8::Arguments& args) {
     // Get the current RenderView so that we can send a routed IPC message from
     // the correct source.
     RenderView* renderview = bindings_utils::GetRenderViewForCurrentContext();
     if (!renderview)
       return v8::Undefined();
 
     if (args.Length() != 3 || !args[0]->IsString() || !args[1]->IsInt32() ||
@@ skipping 41 matching lines @@
   argv[0] = v8::Integer::New(request_id);
   argv[1] = v8::String::New(request->name.c_str());
   argv[2] = v8::Boolean::New(success);
   argv[3] = v8::String::New(response.c_str());
   argv[4] = v8::String::New(error.c_str());
   bindings_utils::CallFunctionInContext(
       request->context, "handleResponse", arraysize(argv), argv);
 
   GetPendingRequestMap().erase(request_id);
 }
+
+// static
+void ExtensionProcessBindings::SetPageActions(
+    const std::string& extension_id,
+    const std::vector<std::string>& page_actions) {
+  PageActionIdMap& page_action_map = *GetPageActionMap();
+  if (!page_actions.empty()) {
+    page_action_map[extension_id] = page_actions;
+  } else {
+    if (page_action_map.find(extension_id) != page_action_map.end())
+      page_action_map.erase(extension_id);
+  }
+}