remove toolstrips

chrome/renderer/extensions/extension_process_bindings.cc

 // Copyright (c) 2010 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 <map>
 #include <set>
 #include <string>
 #include <vector>
@@ skipping 183 matching lines @@
 
   // 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;
   }
 
   std::string extension_id_;
   int browser_window_id_;
   ViewType::Type view_type_;
   v8::Local<v8::Array> views_;
   int index_;
 };
 
@@ skipping 61 matching lines @@
   }
 
   static v8::Handle<v8::Value> PopupViewFinder(
       const v8::Arguments& args,
       ViewType::Type viewtype_to_find) {
     // TODO(twiz)  Correct the logic that ties the ownership of the pop-up view
     // to the hosting view.  At the moment we assume that there may only be
     // a single pop-up view for a given extension.  By doing so, we can find
     // the pop-up view by simply searching for the only pop-up view present.
     // We also assume that if the current view is a pop-up, we can find the
-    // hosting view by searching for a TOOLSTRIP view.
+    // hosting view by searching for a tab contents view.
     if (args.Length() != 0)
       return v8::Undefined();
 
     if (viewtype_to_find != ViewType::EXTENSION_POPUP &&
-        viewtype_to_find != ViewType::EXTENSION_TOOLSTRIP) {
+        viewtype_to_find != ViewType::TAB_CONTENTS) {
       NOTREACHED() << "Requesting invalid view type.";
     }
 
-    // Disallow searching for a host view if we are a popup view, and likewise
-    // if we are a toolstrip view.
+    // Disallow searching for the same view type as the current view:
+    // Popups can only look for hosts, and hosts can only look for popups.
     RenderView* render_view = bindings_utils::GetRenderViewForCurrentContext();
     if (!render_view ||
         render_view->view_type() == viewtype_to_find) {
       return v8::Undefined();
     }
 
     int browser_window_id = render_view->browser_window_id();
     std::string extension_id = ExtensionIdForCurrentContext();
     if (extension_id.empty())
       return v8::Undefined();
 
     ExtensionViewAccumulator  popup_matcher(extension_id,
                                             browser_window_id,
                                             viewtype_to_find);
     RenderView::ForEach(&popup_matcher);
 
     if (0 == popup_matcher.views()->Length())
       return v8::Undefined();
     DCHECK(1 == popup_matcher.views()->Length());
 
     // Return the first view found.
     return popup_matcher.views()->Get(v8::Integer::New(0));
   }
 
   static v8::Handle<v8::Value> GetPopupView(const v8::Arguments& args) {
     return PopupViewFinder(args, ViewType::EXTENSION_POPUP);
   }
 
   static v8::Handle<v8::Value> GetPopupParentWindow(const v8::Arguments& args) {
-    return PopupViewFinder(args, ViewType::EXTENSION_TOOLSTRIP);
+    return PopupViewFinder(args, ViewType::TAB_CONTENTS);
   }
 
   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| == extension_misc::kUnknownWindowId 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());
     StringToUpperASCII(&view_type_string);
     // |view_type| == ViewType::INVALID means getting any type of views.
     ViewType::Type view_type = ViewType::INVALID;
-    if (view_type_string == ViewType::kToolstrip) {
-      view_type = ViewType::EXTENSION_TOOLSTRIP;
-    } else if (view_type_string == ViewType::kMole) {
-      view_type = ViewType::EXTENSION_MOLE;
-    } else if (view_type_string == ViewType::kBackgroundPage) {
+    if (view_type_string == ViewType::kBackgroundPage) {
       view_type = ViewType::EXTENSION_BACKGROUND_PAGE;
     } else if (view_type_string == ViewType::kInfobar) {
       view_type = ViewType::EXTENSION_INFOBAR;
     } else if (view_type_string == ViewType::kNotification) {
       view_type = ViewType::NOTIFICATION;
     } else if (view_type_string == ViewType::kTabContents) {
       view_type = ViewType::TAB_CONTENTS;
     } else if (view_type_string == ViewType::kPopup) {
       view_type = ViewType::EXTENSION_POPUP;
     } else if (view_type_string != ViewType::kAll) {
@@ skipping 337 matching lines @@
       const std::string& function_name) {
   static const char kMessage[] =
       "You do not have permission to use '%s'. Be sure to declare"
       " in your manifest what permissions you need.";
   std::string error_msg = StringPrintf(kMessage, function_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->mainFrame();
-  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);
-}