Move c/r/extensions/* into extensions namespace

chrome/renderer/chrome_content_renderer_client.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/chrome_content_renderer_client.h"
 
 #include <string>
 
 #include "base/command_line.h"
 #include "base/logging.h"
@@ skipping 18 matching lines @@
 #include "chrome/renderer/autofill/autofill_agent.h"
 #include "chrome/renderer/autofill/password_autofill_manager.h"
 #include "chrome/renderer/autofill/password_generation_manager.h"
 #include "chrome/renderer/automation/automation_renderer_helper.h"
 #include "chrome/renderer/benchmarking_extension.h"
 #include "chrome/renderer/chrome_render_process_observer.h"
 #include "chrome/renderer/chrome_render_view_observer.h"
 #include "chrome/renderer/content_settings_observer.h"
 #include "chrome/renderer/extensions/chrome_v8_context.h"
 #include "chrome/renderer/extensions/chrome_v8_extension.h"
-#include "chrome/renderer/extensions/extension_dispatcher.h"
+#include "chrome/renderer/extensions/dispatcher.h"
 #include "chrome/renderer/extensions/extension_helper.h"
-#include "chrome/renderer/extensions/extension_resource_request_policy.h"
 #include "chrome/renderer/extensions/miscellaneous_bindings.h"
+#include "chrome/renderer/extensions/resource_request_policy.h"
 #include "chrome/renderer/external_extension.h"
 #include "chrome/renderer/loadtimes_extension_bindings.h"
 #include "chrome/renderer/localized_error.h"
 #include "chrome/renderer/net/renderer_net_predictor.h"
 #include "chrome/renderer/page_click_tracker.h"
 #include "chrome/renderer/page_load_histograms.h"
 #include "chrome/renderer/pepper/chrome_ppapi_interfaces.h"
 #include "chrome/renderer/pepper/pepper_helper.h"
 #include "chrome/renderer/playback_extension.h"
 #include "chrome/renderer/plugins/plugin_placeholder.h"
@@ skipping 94 matching lines @@
 namespace chrome {
 
 ChromeContentRendererClient::ChromeContentRendererClient() {
 }
 
 ChromeContentRendererClient::~ChromeContentRendererClient() {
 }
 
 void ChromeContentRendererClient::RenderThreadStarted() {
   chrome_observer_.reset(new ChromeRenderProcessObserver(this));
-  extension_dispatcher_.reset(new ExtensionDispatcher());
+  extension_dispatcher_.reset(new extensions::Dispatcher());
   net_predictor_.reset(new RendererNetPredictor());
   spellcheck_.reset(new SpellCheck());
   visited_link_slave_.reset(new VisitedLinkSlave());
 #if defined(ENABLE_SAFE_BROWSING)
   phishing_classifier_.reset(safe_browsing::PhishingClassifierFilter::Create());
 #endif
   prerender_dispatcher_.reset(new prerender::PrerenderDispatcher());
 
   RenderThread* thread = RenderThread::Get();
 
@@ skipping 82 matching lines @@
 }
 
 void ChromeContentRendererClient::RenderViewCreated(
     content::RenderView* render_view) {
   ContentSettingsObserver* content_settings =
       new ContentSettingsObserver(render_view);
   if (chrome_observer_.get()) {
     content_settings->SetContentSettingRules(
         chrome_observer_->content_setting_rules());
   }
-  new ExtensionHelper(render_view, extension_dispatcher_.get());
+  new extensions::ExtensionHelper(render_view, extension_dispatcher_.get());
   new PageLoadHistograms(render_view);
 #if defined(ENABLE_PRINTING)
   new PrintWebViewHelper(render_view);
 #endif
   new SearchBox(render_view);
   new SpellCheckProvider(render_view, this);
   new prerender::PrerendererClient(render_view);
 #if defined(ENABLE_SAFE_BROWSING)
   safe_browsing::MalwareDOMDetails::Create(render_view);
 #endif
@@ skipping 43 matching lines @@
     content::RenderView* render_view,
     WebFrame* frame,
     const WebPluginParams& params,
     WebPlugin** plugin) {
   ChromeViewHostMsg_GetPluginInfo_Status status;
   webkit::WebPluginInfo plugin_info;
   std::string actual_mime_type;
   std::string orig_mime_type = params.mimeType.utf8();
 
   if (orig_mime_type == content::kBrowserPluginMimeType &&
-      ExtensionHelper::Get(render_view)->view_type() == VIEW_TYPE_APP_SHELL)
+      extensions::ExtensionHelper::Get(render_view)->view_type() ==
+          VIEW_TYPE_APP_SHELL)
       return false;
 
   render_view->Send(new ChromeViewHostMsg_GetPluginInfo(
       render_view->GetRoutingID(), GURL(params.url),
       frame->top()->document().url(), orig_mime_type,
       &status, &plugin_info, &actual_mime_type));
   *plugin = CreatePlugin(render_view, frame, params,
                          status, plugin_info, actual_mime_type);
   return true;
 }
@@ skipping 371 matching lines @@
     if (!extension && !is_repost)
       *error_description = LocalizedError::GetErrorDetails(error);
   }
 }
 
 bool ChromeContentRendererClient::RunIdleHandlerWhenWidgetsHidden() {
   return !extension_dispatcher_->is_extension_process();
 }
 
 bool ChromeContentRendererClient::AllowPopup(const GURL& creator) {
-  ChromeV8Context* current_context =
+  extensions::ChromeV8Context* current_context =
       extension_dispatcher_->v8_context_set().GetCurrent();
   return current_context && current_context->extension();
 }
 
 bool ChromeContentRendererClient::ShouldFork(WebFrame* frame,
                                              const GURL& url,
                                              bool is_initial_navigation,
                                              bool* send_referrer) {
   DCHECK(!frame->parent());
 
@@ skipping 46 matching lines @@
 
   return false;
 }
 
 bool ChromeContentRendererClient::WillSendRequest(WebKit::WebFrame* frame,
                                                   const GURL& url,
                                                   GURL* new_url) {
   // Check whether the request should be allowed. If not allowed, we reset the
   // URL to something invalid to prevent the request and cause an error.
   if (url.SchemeIs(chrome::kExtensionScheme) &&
-      !ExtensionResourceRequestPolicy::CanRequestResource(
+      !extensions::ResourceRequestPolicy::CanRequestResource(
           url,
           frame,
           extension_dispatcher_->extensions())) {
     *new_url = GURL("chrome-extension://invalid/");
     return true;
 
   }
 
   if (url.SchemeIs(chrome::kExtensionResourceScheme) &&
-      !ExtensionResourceRequestPolicy::CanRequestExtensionResourceScheme(
+      !extensions::ResourceRequestPolicy::CanRequestExtensionResourceScheme(
           url,
           frame)) {
     *new_url = GURL("chrome-extension-resource://invalid/");
     return true;
   }
 
   return false;
 }
 
 bool ChromeContentRendererClient::ShouldPumpEventsDuringCookieMessage() {
@@ skipping 60 matching lines @@
     const std::string& value) {
   if (CommandLine::ForCurrentProcess()->HasSwitch(switches::kChromeFrame)) {
     sender->Send(new ChromeViewHostMsg_SetCookie(
         MSG_ROUTING_NONE, url, first_party_for_cookies, value));
     return true;
   }
   return false;
 }
 
 void ChromeContentRendererClient::SetExtensionDispatcher(
-    ExtensionDispatcher* extension_dispatcher) {
+    extensions::Dispatcher* extension_dispatcher) {
   extension_dispatcher_.reset(extension_dispatcher);
 }
 
 bool ChromeContentRendererClient::CrossesExtensionExtents(
     WebFrame* frame,
     const GURL& new_url,
     const ExtensionSet& extensions,
     bool is_extension_url,
     bool is_initial_navigation) {
   GURL old_url(frame->top()->document().url());
@@ skipping 62 matching lines @@
 bool ChromeContentRendererClient::IsOtherExtensionWithWebRequestInstalled() {
   return extension_dispatcher_->IsOtherExtensionWithWebRequestInstalled();
 }
 
 void ChromeContentRendererClient::RegisterPPAPIInterfaceFactories(
     webkit::ppapi::PpapiInterfaceFactoryManager* factory_manager) {
   factory_manager->RegisterFactory(ChromePPAPIInterfaceFactory);
 }
 
 }  // namespace chrome