mole expand/collapse API

chrome/browser/extensions/extension_function_dispatcher.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/browser/extensions/extension_function_dispatcher.h"
 
 #include "base/process_util.h"
 #include "base/singleton.h"
 #include "base/values.h"
 #include "chrome/browser/extensions/extension_bookmarks_module.h"
 #include "chrome/browser/extensions/extension_bookmarks_module_constants.h"
 #include "chrome/browser/extensions/extension_function.h"
 #include "chrome/browser/extensions/extension_message_service.h"
 #include "chrome/browser/extensions/extension_page_actions_module.h"
 #include "chrome/browser/extensions/extension_page_actions_module_constants.h"
 #include "chrome/browser/extensions/extension_process_manager.h"
 #include "chrome/browser/extensions/extension_tabs_module.h"
 #include "chrome/browser/extensions/extension_tabs_module_constants.h"
+#include "chrome/browser/extensions/extension_toolstrip_api.h"
 #include "chrome/browser/profile.h"
 #include "chrome/browser/renderer_host/render_process_host.h"
 #include "chrome/browser/renderer_host/render_view_host.h"
 #include "chrome/common/result_codes.h"
+#include "chrome/common/url_constants.h"
 
 // FactoryRegistry -------------------------------------------------------------
 
 namespace {
 
 // Template for defining ExtensionFunctionFactory.
 template<class T>
 ExtensionFunction* NewExtensionFunction() {
   return new T();
 }
@@ skipping 27 matching lines @@
 FactoryRegistry* FactoryRegistry::instance() {
   return Singleton<FactoryRegistry>::get();
 }
 
 void FactoryRegistry::ResetFunctions() {
   // Register all functions here.
 
   namespace tabs = extension_tabs_module_constants;
   namespace page_actions = extension_page_actions_module_constants;
   namespace bookmarks = extension_bookmarks_module_constants;
+  namespace toolstrip = extension_toolstrip_api_constants;
 
   // Windows
   factories_[tabs::kGetWindowFunction] =
       &NewExtensionFunction<GetWindowFunction>;
   factories_[tabs::kGetCurrentWindowFunction] =
       &NewExtensionFunction<GetCurrentWindowFunction>;
   factories_[tabs::kGetLastFocusedWindowFunction] =
       &NewExtensionFunction<GetLastFocusedWindowFunction>;
   factories_[tabs::kGetAllWindowsFunction] =
       &NewExtensionFunction<GetAllWindowsFunction>;
@@ skipping 40 matching lines @@
   factories_[bookmarks::kRemoveBookmarkFunction] =
       &NewExtensionFunction<RemoveBookmarkFunction>;
   factories_[bookmarks::kRemoveBookmarkTreeFunction] =
     &NewExtensionFunction<RemoveBookmarkFunction>;
   factories_[bookmarks::kCreateBookmarkFunction] =
       &NewExtensionFunction<CreateBookmarkFunction>;
   factories_[bookmarks::kMoveBookmarkFunction] =
       &NewExtensionFunction<MoveBookmarkFunction>;
   factories_[bookmarks::kSetBookmarkTitleFunction] =
       &NewExtensionFunction<SetBookmarkTitleFunction>;
+
+  // Toolstrips.
+  factories_[toolstrip::kExpandFunction] =
+      &NewExtensionFunction<ToolstripExpandFunction>;
+  factories_[toolstrip::kCollapseFunction] =
+      &NewExtensionFunction<ToolstripCollapseFunction>;
 }
 
 void FactoryRegistry::GetAllNames(std::vector<std::string>* names) {
   for (FactoryMap::iterator iter = factories_.begin();
        iter != factories_.end(); ++iter) {
     names->push_back(iter->first);
   }
 }
 
 bool FactoryRegistry::OverrideFunction(const std::string& name,
@@ skipping 40 matching lines @@
 }
 
 ExtensionFunctionDispatcher::ExtensionFunctionDispatcher(
     RenderViewHost* render_view_host,
     Delegate* delegate,
     const GURL& url)
   : render_view_host_(render_view_host),
     delegate_(delegate),
     url_(url),
     ALLOW_THIS_IN_INITIALIZER_LIST(peer_(new Peer(this))) {
+  DCHECK(url.SchemeIs(chrome::kExtensionScheme));
+  // TODO(erikkay) also verify id is valid
+
   all_instances()->insert(this);
 
   // Notify the ExtensionProcessManager that the view was created.
   ExtensionProcessManager* epm = profile()->GetExtensionProcessManager();
   epm->RegisterExtensionProcess(extension_id(),
                                 render_view_host->process()->pid());
 }
 
 ExtensionFunctionDispatcher::~ExtensionFunctionDispatcher() {
   all_instances()->erase(this);
   peer_->dispatcher_ = NULL;
 }
 
 Browser* ExtensionFunctionDispatcher::GetBrowser() {
   DCHECK(delegate_);
 
   Browser* retval = delegate_->GetBrowser();
   return retval;
 }
 
+ExtensionHost* ExtensionFunctionDispatcher::GetHost() {
+  DCHECK(delegate_);
+  return delegate_->GetHost();
+}
+
 void ExtensionFunctionDispatcher::HandleRequest(const std::string& name,
                                                 const std::string& args,
                                                 int request_id,
                                                 bool has_callback) {
   scoped_refptr<ExtensionFunction> function(
       FactoryRegistry::instance()->NewFunction(name));
   function->set_dispatcher_peer(peer_);
   function->SetArgs(args);
   function->set_request_id(request_id);
   function->set_has_callback(has_callback);
@@ skipping 15 matching lines @@
   } else {
     NOTREACHED();
     base::KillProcess(render_view_host_->process()->process().handle(),
                       ResultCodes::KILLED_BAD_MESSAGE, false);
   }
 }
 
 Profile* ExtensionFunctionDispatcher::profile() {
   return render_view_host_->process()->profile();
 }