Change the view mode when switching between moles and toolstrips, and

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/extensions/extension.h"
 #include "chrome/common/extensions/url_pattern.h"
 #include "chrome/common/render_messages.h"
@@ skipping 10 matching lines @@
 #include "webkit/api/public/WebKit.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::PendingRequestMap;
 using bindings_utils::ExtensionBase;
+using WebKit::WebFrame;
 
 namespace {
 
 // A map of extension ID to vector of page action ids.
 typedef std::map< std::string, std::vector<std::string> > PageActionIdMap;
 
 // A map of permission name to whether its enabled for this extension.
 typedef std::map<std::string, bool> PermissionsMap;
 
 // A map of extension ID to permissions map.
@@ skipping 71 matching lines @@
 
     return ExtensionBase::GetNativeFunction(name);
   }
 
  private:
   static v8::Handle<v8::Value> GetExtensionAPIDefinition(
       const v8::Arguments& args) {
     return v8::String::New(GetStringResource<IDR_EXTENSION_API_JSON>());
   }
 
+  // Returns true is |type| "isa" |match|.
+  static bool ViewTypeMatches(ViewType::Type type, ViewType::Type match) {
+    if (type == match)
+      return true;
+
+    // INVALID means match all.
+    if (match == ViewType::INVALID)
+      return true;
+
+    // TODO(erikkay) for now, special case mole as a type of toolstrip.
+    // Perhaps this isn't the right long-term thing to do.
+    if (match == ViewType::EXTENSION_TOOLSTRIP && 
+        type == ViewType::EXTENSION_MOLE) {
+      return true;
+    }
+
+    return false;
+  }
+
   static v8::Handle<v8::Value> GetExtensionViews(const v8::Arguments& args) {
     if (args.Length() != 2)
       return v8::Undefined();
 
     if (!args[0]->IsInt32() || !args[1]->IsString())
       return v8::Undefined();
 
     // |browser_window_id| == -1 means getting views attached to any browser
     // window.
     int browser_window_id = args[0]->Int32Value();
 
     std::string view_type_string = *v8::String::Utf8Value(args[1]->ToString());
     // |view_type| == ViewType::INVALID means getting any type of views.
     ViewType::Type view_type = ViewType::INVALID;
     if (view_type_string == "TOOLSTRIP") {
       view_type = ViewType::EXTENSION_TOOLSTRIP;
+    } else if (view_type_string == "MOLE") {
+      view_type = ViewType::EXTENSION_MOLE;
     } else if (view_type_string == "BACKGROUND") {
       view_type = ViewType::EXTENSION_BACKGROUND_PAGE;
     } else if (view_type_string == "TAB") {
       view_type = ViewType::TAB_CONTENTS;
     } else if (view_type_string != "ALL") {
       return v8::Undefined();
     }
 
     v8::Local<v8::Array> views = v8::Array::New();
     int index = 0;
     RenderView::RenderViewSet* render_view_set_pointer =
         Singleton<RenderView::RenderViewSet>::get();
     DCHECK(render_view_set_pointer->render_view_set_.size() > 0);
 
     v8::Local<v8::Value> window;
     std::string current_extension_id = ExtensionIdForCurrentContext();
     std::set<RenderView* >::iterator it =
         render_view_set_pointer->render_view_set_.begin();
     for (; it != render_view_set_pointer->render_view_set_.end(); ++it) {
-      if (view_type != ViewType::INVALID && (*it)->view_type() != view_type)
+      if (!ViewTypeMatches((*it)->view_type(), view_type))
         continue;
 
       GURL url = (*it)->webview()->GetMainFrame()->url();
       if (!url.SchemeIs(chrome::kExtensionScheme))
         continue;
       std::string extension_id = url.host();
       if (extension_id != current_extension_id)
         continue;
 
       if (browser_window_id != -1 &&
@@ skipping 221 matching lines @@
       const std::string& function_name) {
   static const char kMessage[] =
       "You do not have permission to use 'chrome.%s'. Be sure to declare"
       " in your manifest what permissions you need.";
   std::string permission_name = GetPermissionName(function_name);
   std::string error_msg = StringPrintf(kMessage, permission_name.c_str());
 
   return v8::ThrowException(v8::Exception::Error(
       v8::String::New(error_msg.c_str())));
 }
+
+// static
+void ExtensionProcessBindings::SetViewType(WebView* view,
+                                           ViewType::Type type) {
+  DCHECK(type == ViewType::EXTENSION_MOLE ||
+         type == ViewType::EXTENSION_TOOLSTRIP);
+  const char* type_str;
+  if (type == ViewType::EXTENSION_MOLE)
+    type_str = "mole";
+  else if (type == ViewType::EXTENSION_TOOLSTRIP)
+    type_str = "toolstrip";
+  else
+    return;
+
+  v8::HandleScope handle_scope;
+  WebFrame* frame = view->GetMainFrame();
+  v8::Local<v8::Context> context = frame->mainWorldScriptContext();
+  v8::Handle<v8::Value> argv[1];
+  argv[0] = v8::String::New(type_str);
+  bindings_utils::CallFunctionInContext(context, "setViewType",
+                                        arraysize(argv), argv);
+}