Move the ViewType enum to extensions\common.

chrome/renderer/extensions/extension_helper.cc

 // Copyright (c) 2012 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_helper.h"
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/command_line.h"
 #include "base/json/json_string_value_serializer.h"
 #include "base/lazy_instance.h"
 #include "base/message_loop.h"
 #include "base/utf_string_conversions.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/common/extensions/extension_messages.h"
 #include "chrome/common/render_messages.h"
 #include "chrome/common/url_constants.h"
-#include "chrome/common/view_type.h"
 #include "chrome/renderer/extensions/chrome_v8_context.h"
 #include "chrome/renderer/extensions/console.h"
 #include "chrome/renderer/extensions/dispatcher.h"
 #include "chrome/renderer/extensions/miscellaneous_bindings.h"
 #include "chrome/renderer/extensions/user_script_scheduler.h"
 #include "chrome/renderer/extensions/user_script_slave.h"
 #include "content/public/renderer/render_view.h"
 #include "content/public/renderer/render_view_visitor.h"
 #include "extensions/common/constants.h"
 #include "third_party/WebKit/Source/Platform/chromium/public/WebURLRequest.h"
@@ skipping 31 matching lines @@
     LAZY_INSTANCE_INITIALIZER;
 
 // A RenderViewVisitor class that iterates through the set of available
 // views, looking for a view of the given type, in the given browser window
 // and within the given extension.
 // Used to accumulate the list of views associated with an extension.
 class ViewAccumulator : public content::RenderViewVisitor {
  public:
   ViewAccumulator(const std::string& extension_id,
                   int browser_window_id,
-                  chrome::ViewType view_type)
+                  ViewType view_type)
       : extension_id_(extension_id),
         browser_window_id_(browser_window_id),
         view_type_(view_type) {
   }
 
   std::vector<content::RenderView*> views() { return views_; }
 
   // Returns false to terminate the iteration.
   virtual bool Visit(content::RenderView* render_view) OVERRIDE {
     ExtensionHelper* helper = ExtensionHelper::Get(render_view);
     if (!ViewTypeMatches(helper->view_type(), view_type_))
       return true;
 
     GURL url = render_view->GetWebView()->mainFrame()->document().url();
-    if (!url.SchemeIs(extensions::kExtensionScheme))
+    if (!url.SchemeIs(kExtensionScheme))
       return true;
     const std::string& extension_id = url.host();
     if (extension_id != extension_id_)
       return true;
 
     if (browser_window_id_ != extension_misc::kUnknownWindowId &&
         helper->browser_window_id() != browser_window_id_) {
       return true;
     }
 
     views_.push_back(render_view);
 
-    if (view_type_ == chrome::VIEW_TYPE_EXTENSION_BACKGROUND_PAGE)
+    if (view_type_ == VIEW_TYPE_EXTENSION_BACKGROUND_PAGE)
       return false;  // There can be only one...
     return true;
   }
 
  private:
   // Returns true if |type| "isa" |match|.
-  static bool ViewTypeMatches(chrome::ViewType type, chrome::ViewType match) {
+  static bool ViewTypeMatches(ViewType type, ViewType match) {
     if (type == match)
       return true;
 
     // INVALID means match all.
-    if (match == chrome::VIEW_TYPE_INVALID)
+    if (match == VIEW_TYPE_INVALID)
       return true;
 
     return false;
   }
 
   std::string extension_id_;
   int browser_window_id_;
-  chrome::ViewType view_type_;
+  ViewType view_type_;
   std::vector<content::RenderView*> views_;
 };
 
 }  // namespace
 
 // static
 std::vector<content::RenderView*> ExtensionHelper::GetExtensionViews(
     const std::string& extension_id,
     int browser_window_id,
-    chrome::ViewType view_type) {
+    ViewType view_type) {
   ViewAccumulator accumulator(extension_id, browser_window_id, view_type);
   content::RenderView::ForEach(&accumulator);
   return accumulator.views();
 }
 
 // static
 content::RenderView* ExtensionHelper::GetBackgroundPage(
     const std::string& extension_id) {
   ViewAccumulator accumulator(extension_id, extension_misc::kUnknownWindowId,
-                              chrome::VIEW_TYPE_EXTENSION_BACKGROUND_PAGE);
+                              VIEW_TYPE_EXTENSION_BACKGROUND_PAGE);
   content::RenderView::ForEach(&accumulator);
   CHECK_LE(accumulator.views().size(), 1u);
   if (accumulator.views().size() == 0)
     return NULL;
   return accumulator.views()[0];
 }
 
 ExtensionHelper::ExtensionHelper(content::RenderView* render_view,
                                  Dispatcher* dispatcher)
     : content::RenderViewObserver(render_view),
       content::RenderViewObserverTracker<ExtensionHelper>(render_view),
       dispatcher_(dispatcher),
       pending_app_icon_requests_(0),
-      view_type_(chrome::VIEW_TYPE_INVALID),
+      view_type_(VIEW_TYPE_INVALID),
       tab_id_(-1),
       browser_window_id_(-1) {
 }
 
 ExtensionHelper::~ExtensionHelper() {
 }
 
 bool ExtensionHelper::OnMessageReceived(const IPC::Message& message) {
   bool handled = true;
   IPC_BEGIN_MESSAGE_MAP(ExtensionHelper, message)
@@ skipping 47 matching lines @@
 
 void ExtensionHelper::DidStartProvisionalLoad(WebKit::WebFrame* frame) {
   SchedulerMap::iterator i = g_schedulers.Get().find(frame);
   if (i != g_schedulers.Get().end())
     i->second->DidStartProvisionalLoad();
 }
 
 void ExtensionHelper::DraggableRegionsChanged(WebKit::WebFrame* frame) {
   WebKit::WebVector<WebKit::WebDraggableRegion> webregions =
       frame->document().draggableRegions();
-  std::vector<extensions::DraggableRegion> regions;
+  std::vector<DraggableRegion> regions;
   for (size_t i = 0; i < webregions.size(); ++i) {
-    extensions::DraggableRegion region;
+    DraggableRegion region;
     region.bounds = webregions[i].bounds;
     region.draggable = webregions[i].draggable;
     regions.push_back(region);
   }
   Send(new ExtensionHostMsg_UpdateDraggableRegions(routing_id(), regions));
 }
 
 void ExtensionHelper::FrameDetached(WebFrame* frame) {
   // This could be called before DidCreateDataSource, in which case the frame
   // won't be in the map.
@@ skipping 109 matching lines @@
     if (app_info.icons[i].url.SchemeIs(chrome::kDataScheme)) {
       app_info.icons.erase(app_info.icons.begin() + i);
       --i;
     }
   }
 
   Send(new ExtensionHostMsg_DidGetApplicationInfo(
       routing_id(), page_id, app_info));
 }
 
-void ExtensionHelper::OnNotifyRendererViewType(chrome::ViewType type) {
+void ExtensionHelper::OnNotifyRendererViewType(ViewType type) {
   view_type_ = type;
 }
 
 void ExtensionHelper::OnSetTabId(int init_tab_id) {
   CHECK_EQ(tab_id_, -1);
   CHECK_GE(init_tab_id, 0);
   tab_id_ = init_tab_id;
 }
 
 void ExtensionHelper::OnUpdateBrowserWindowId(int window_id) {
@@ skipping 10 matching lines @@
   v8::Handle<v8::Context> script_context =
       render_view()->GetWebView()->mainFrame()->mainWorldScriptContext();
   ChromeV8Context* chrome_v8_context =
       dispatcher_->v8_context_set().GetByV8Context(script_context);
   if (!chrome_v8_context)
     return;
   chrome_v8_context->CallChromeHiddenMethod("OnAppWindowClosed", 0, NULL, NULL);
 }
 
 }  // namespace extensions