Move c/r/extensions/* into extensions namespace

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/extension_dispatcher.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 "third_party/WebKit/Source/WebKit/chromium/public/WebConsoleMessage.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebDocument.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebFrame.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/platform/WebURLRequest.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebScopedUserGesture.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebView.h"
 #include "webkit/glue/image_resource_fetcher.h"
 #include "webkit/glue/resource_fetcher.h"
 
 namespace base {
 class ListValue;
 }  // namespace base
 
 using content::ConsoleMessageLevel;
-using extensions::MiscellaneousBindings;
 using WebKit::WebConsoleMessage;
 using WebKit::WebDataSource;
 using WebKit::WebFrame;
 using WebKit::WebURLRequest;
 using WebKit::WebScopedUserGesture;
 using WebKit::WebView;
 using webkit_glue::ImageResourceFetcher;
 using webkit_glue::ResourceFetcher;
 
+namespace extensions {
+
 namespace {
 // Keeps a mapping from the frame pointer to a UserScriptScheduler object.
 // We store this mapping per process, because a frame can jump from one
 // document to another with adoptNode, and so having the object be a
 // RenderViewObserver means it might miss some notifications after it moves.
-typedef std::map<WebFrame*, extensions::UserScriptScheduler*> SchedulerMap;
+typedef std::map<WebFrame*, UserScriptScheduler*> SchedulerMap;
 static base::LazyInstance<SchedulerMap> g_schedulers =
     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 ExtensionViewAccumulator : public content::RenderViewVisitor {
+class ViewAccumulator : public content::RenderViewVisitor {
  public:
-  ExtensionViewAccumulator(const std::string& extension_id,
-                           int browser_window_id,
-                           chrome::ViewType view_type)
+  ViewAccumulator(const std::string& extension_id,
+                  int browser_window_id,
+                  chrome::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) {
     ExtensionHelper* helper = ExtensionHelper::Get(render_view);
@@ skipping 38 matching lines @@
   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) {
-  ExtensionViewAccumulator accumulator(
-      extension_id, browser_window_id, 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) {
-  ExtensionViewAccumulator accumulator(
-      extension_id, extension_misc::kUnknownWindowId,
-      chrome::VIEW_TYPE_EXTENSION_BACKGROUND_PAGE);
+  ViewAccumulator accumulator(extension_id, extension_misc::kUnknownWindowId,
+                              chrome::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,
-                                 ExtensionDispatcher* extension_dispatcher)
+                                 Dispatcher* dispatcher)
     : content::RenderViewObserver(render_view),
       content::RenderViewObserverTracker<ExtensionHelper>(render_view),
-      extension_dispatcher_(extension_dispatcher),
+      dispatcher_(dispatcher),
       pending_app_icon_requests_(0),
       view_type_(chrome::VIEW_TYPE_INVALID),
       tab_id_(-1),
       browser_window_id_(-1) {
 }
 
 ExtensionHelper::~ExtensionHelper() {
 }
 
 bool ExtensionHelper::InstallWebApplicationUsingDefinitionFile(
@@ skipping 61 matching lines @@
     IPC_MESSAGE_HANDLER(ExtensionMsg_NotifyRenderViewType,
                         OnNotifyRendererViewType)
     IPC_MESSAGE_HANDLER(ExtensionMsg_AddMessageToConsole,
                         OnAddMessageToConsole)
     IPC_MESSAGE_UNHANDLED(handled = false)
   IPC_END_MESSAGE_MAP()
   return handled;
 }
 
 void ExtensionHelper::DidFinishDocumentLoad(WebFrame* frame) {
-  extension_dispatcher_->user_script_slave()->InjectScripts(
-      frame, extensions::UserScript::DOCUMENT_END);
+  dispatcher_->user_script_slave()->InjectScripts(
+      frame, UserScript::DOCUMENT_END);
 
   SchedulerMap::iterator i = g_schedulers.Get().find(frame);
   if (i != g_schedulers.Get().end())
     i->second->DidFinishDocumentLoad();
 }
 
 void ExtensionHelper::DidFinishLoad(WebKit::WebFrame* frame) {
   SchedulerMap::iterator i = g_schedulers.Get().find(frame);
   if (i != g_schedulers.Get().end())
     i->second->DidFinishLoad();
 }
 
 void ExtensionHelper::DidCreateDocumentElement(WebFrame* frame) {
-  extension_dispatcher_->user_script_slave()->InjectScripts(
-      frame, extensions::UserScript::DOCUMENT_START);
+  dispatcher_->user_script_slave()->InjectScripts(
+      frame, UserScript::DOCUMENT_START);
   SchedulerMap::iterator i = g_schedulers.Get().find(frame);
   if (i != g_schedulers.Get().end())
     i->second->DidCreateDocumentElement();
 }
 
 void ExtensionHelper::DidStartProvisionalLoad(WebKit::WebFrame* frame) {
   SchedulerMap::iterator i = g_schedulers.Get().find(frame);
   if (i != g_schedulers.Get().end())
     i->second->DidStartProvisionalLoad();
 }
@@ skipping 15 matching lines @@
   if (!frame->parent()) {
     app_icon_fetchers_.clear();
     app_definition_fetcher_.reset(NULL);
   }
 
   // Check first if we created a scheduler for the frame, since this function
   // gets called for navigations within the document.
   if (g_schedulers.Get().count(frame))
     return;
 
-  g_schedulers.Get()[frame] = new extensions::UserScriptScheduler(
-      frame, extension_dispatcher_);
+  g_schedulers.Get()[frame] = new UserScriptScheduler(frame, dispatcher_);
 }
 
 void ExtensionHelper::OnExtensionResponse(int request_id,
                                           bool success,
                                           const base::ListValue& response,
                                           const std::string& error) {
-  extension_dispatcher_->OnExtensionResponse(request_id,
-                                             success,
-                                             response,
-                                             error);
+  dispatcher_->OnExtensionResponse(request_id,
+                                   success,
+                                   response,
+                                   error);
 }
 
 void ExtensionHelper::OnExtensionMessageInvoke(const std::string& extension_id,
                                                const std::string& function_name,
                                                const base::ListValue& args,
                                                const GURL& event_url,
                                                bool user_gesture) {
   scoped_ptr<WebScopedUserGesture> web_user_gesture;
   if (user_gesture) {
     web_user_gesture.reset(new WebScopedUserGesture);
   }
 
-  extension_dispatcher_->v8_context_set().DispatchChromeHiddenMethod(
+  dispatcher_->v8_context_set().DispatchChromeHiddenMethod(
       extension_id, function_name, args, render_view(), event_url);
 }
 
 void ExtensionHelper::OnExtensionDispatchOnConnect(
     int target_port_id,
     const std::string& channel_name,
     const std::string& tab_json,
     const std::string& source_extension_id,
     const std::string& target_extension_id) {
   MiscellaneousBindings::DispatchOnConnect(
-      extension_dispatcher_->v8_context_set().GetAll(),
+      dispatcher_->v8_context_set().GetAll(),
       target_port_id, channel_name, tab_json,
       source_extension_id, target_extension_id,
       render_view());
 }
 
 void ExtensionHelper::OnExtensionDeliverMessage(int target_id,
                                                 const std::string& message) {
-  MiscellaneousBindings::DeliverMessage(
-      extension_dispatcher_->v8_context_set().GetAll(),
-      target_id,
-      message,
-      render_view());
+  MiscellaneousBindings::DeliverMessage(dispatcher_->v8_context_set().GetAll(),
+                                        target_id,
+                                        message,
+                                        render_view());
 }
 
 void ExtensionHelper::OnExtensionDispatchOnDisconnect(int port_id,
                                                       bool connection_error) {
   MiscellaneousBindings::DispatchOnDisconnect(
-      extension_dispatcher_->v8_context_set().GetAll(),
+      dispatcher_->v8_context_set().GetAll(),
       port_id, connection_error,
       render_view());
 }
 
 void ExtensionHelper::OnExecuteCode(
     const ExtensionMsg_ExecuteCode_Params& params) {
   WebView* webview = render_view()->GetWebView();
   WebFrame* main_frame = webview->mainFrame();
   if (!main_frame) {
     ListValue val;
@@ skipping 163 matching lines @@
         target_level = WebConsoleMessage::LevelWarning;
         break;
       case content::CONSOLE_MESSAGE_LEVEL_ERROR:
         target_level = WebConsoleMessage::LevelError;
         break;
     }
     render_view()->GetWebView()->mainFrame()->addMessageToConsole(
         WebConsoleMessage(target_level, message));
   }
 }
+
+}  // namespace extensions