Move a bunch of code in content\renderer to the content namespace.

content/renderer/render_thread_impl.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 "content/renderer/render_thread_impl.h"
 
 #include <algorithm>
 #include <limits>
 #include <map>
 #include <vector>
@@ skipping 100 matching lines @@
 #endif
 
 using WebKit::WebDocument;
 using WebKit::WebFrame;
 using WebKit::WebNetworkStateNotifier;
 using WebKit::WebRuntimeFeatures;
 using WebKit::WebScriptController;
 using WebKit::WebSecurityPolicy;
 using WebKit::WebString;
 using WebKit::WebView;
-using content::AudioRendererMixerManager;
-using content::RenderProcessObserver;
+
+namespace content {
 
 namespace {
 
 const int64 kInitialIdleHandlerDelayMs = 1000;
 const int64 kShortIdleHandlerDelayMs = 1000;
 const int64 kLongIdleHandlerDelayMs = 30*1000;
 const int kIdleCPUUsageThresholdInPercents = 3;
 
 // Keep the global RenderThreadImpl in a TLS slot so it is impossible to access
 // incorrectly from the wrong thread.
 base::LazyInstance<base::ThreadLocalPointer<RenderThreadImpl> >
     lazy_tls = LAZY_INSTANCE_INITIALIZER;
 
-class RenderViewZoomer : public content::RenderViewVisitor {
+class RenderViewZoomer : public RenderViewVisitor {
  public:
   RenderViewZoomer(const std::string& host, double zoom_level)
       : host_(host), zoom_level_(zoom_level) {
   }
 
-  virtual bool Visit(content::RenderView* render_view) {
+  virtual bool Visit(RenderView* render_view) {
     WebView* webview = render_view->GetWebView();
     WebDocument document = webview->mainFrame()->document();
 
     // Don't set zoom level for full-page plugin since they don't use the same
     // zoom settings.
     if (document.isPluginDocument())
       return true;
 
     if (net::GetHostOrSpecFromURL(GURL(document.url())) == host_)
       webview->setZoomLevel(false, zoom_level_);
@@ skipping 137 matching lines @@
   widget_count_ = 0;
   hidden_widget_count_ = 0;
   idle_notification_delay_in_ms_ = kInitialIdleHandlerDelayMs;
   idle_notifications_to_skip_ = 0;
   compositor_initialized_ = false;
 
   appcache_dispatcher_.reset(new AppCacheDispatcher(Get()));
   dom_storage_dispatcher_.reset(new DomStorageDispatcher());
   main_thread_indexed_db_dispatcher_.reset(new IndexedDBDispatcher());
 
-  browser_plugin_registry_.reset(new content::old::BrowserPluginRegistry());
+  browser_plugin_registry_.reset(new old::BrowserPluginRegistry());
   browser_plugin_channel_manager_.reset(
-      new content::old::BrowserPluginChannelManager());
+      new old::BrowserPluginChannelManager());
   AddObserver(browser_plugin_channel_manager_.get());
 
   media_stream_center_ = NULL;
 
   db_message_filter_ = new DBMessageFilter();
   AddFilter(db_message_filter_.get());
 
 #if defined(ENABLE_WEBRTC)
-  p2p_socket_dispatcher_ = new content::P2PSocketDispatcher(
-      GetIOMessageLoopProxy());
+  p2p_socket_dispatcher_ = new P2PSocketDispatcher(GetIOMessageLoopProxy());
   AddFilter(p2p_socket_dispatcher_);
 #endif  // defined(ENABLE_WEBRTC)
   vc_manager_ = new VideoCaptureImplManager();
   AddFilter(vc_manager_->video_capture_message_filter());
 
   audio_input_message_filter_ = new AudioInputMessageFilter();
   AddFilter(audio_input_message_filter_.get());
 
   audio_message_filter_ = new AudioMessageFilter();
   AddFilter(audio_message_filter_.get());
 
   AddFilter(new IndexedDBMessageFilter);
 
-  content::GetContentClient()->renderer()->RenderThreadStarted();
+  GetContentClient()->renderer()->RenderThreadStarted();
 
   const CommandLine& command_line = *CommandLine::ForCurrentProcess();
   if (command_line.HasSwitch(switches::kEnableGpuBenchmarking))
-      RegisterExtension(content::GpuBenchmarkingExtension::Get());
+      RegisterExtension(GpuBenchmarkingExtension::Get());
 
   context_lost_cb_.reset(new GpuVDAContextLostCallback());
 
   // Note that under Linux, the media library will normally already have
   // been initialized by the Zygote before this instance became a Renderer.
   FilePath media_path;
-  PathService::Get(content::DIR_MEDIA_LIBS, &media_path);
+  PathService::Get(DIR_MEDIA_LIBS, &media_path);
   if (!media_path.empty())
     media::InitializeMediaLibrary(media_path);
 
   TRACE_EVENT_END_ETW("RenderThreadImpl::Init", 0, "");
 }
 
 RenderThreadImpl::~RenderThreadImpl() {
   FOR_EACH_OBSERVER(
       RenderProcessObserver, observers_, OnRenderProcessShutdown());
 
@@ skipping 60 matching lines @@
   // callbacks, timers, and pending network loads that could trigger such
   // callbacks.
   bool pumping_events = false;
   if (msg->is_sync()) {
     if (msg->is_caller_pumping_messages()) {
       pumping_events = true;
     } else {
       if ((msg->type() == ViewHostMsg_GetCookies::ID ||
            msg->type() == ViewHostMsg_GetRawCookies::ID ||
            msg->type() == ViewHostMsg_CookiesEnabled::ID) &&
-          content::GetContentClient()->renderer()->
+          GetContentClient()->renderer()->
               ShouldPumpEventsDuringCookieMessage()) {
         pumping_events = true;
       }
     }
   }
 
   bool suspend_webkit_shared_timer = true;  // default value
   std::swap(suspend_webkit_shared_timer, suspend_webkit_shared_timer_);
 
   bool notify_webkit_of_modal_loop = true;  // default value
@@ skipping 86 matching lines @@
 }
 
 void RenderThreadImpl::RemoveFilter(IPC::ChannelProxy::MessageFilter* filter) {
   channel()->RemoveFilter(filter);
 }
 
 void RenderThreadImpl::SetOutgoingMessageFilter(
     IPC::ChannelProxy::OutgoingMessageFilter* filter) {
 }
 
-void RenderThreadImpl::AddObserver(content::RenderProcessObserver* observer) {
+void RenderThreadImpl::AddObserver(RenderProcessObserver* observer) {
   observers_.AddObserver(observer);
 }
 
-void RenderThreadImpl::RemoveObserver(
-    content::RenderProcessObserver* observer) {
+void RenderThreadImpl::RemoveObserver(RenderProcessObserver* observer) {
   observers_.RemoveObserver(observer);
 }
 
 void RenderThreadImpl::SetResourceDispatcherDelegate(
-    content::ResourceDispatcherDelegate* delegate) {
+    ResourceDispatcherDelegate* delegate) {
   resource_dispatcher()->set_delegate(delegate);
 }
 
 void RenderThreadImpl::WidgetHidden() {
   DCHECK(hidden_widget_count_ < widget_count_);
   hidden_widget_count_++;
 
-  if (!content::GetContentClient()->renderer()->
-          RunIdleHandlerWhenWidgetsHidden()) {
+  if (!GetContentClient()->renderer()->RunIdleHandlerWhenWidgetsHidden()) {
     return;
   }
 
   if (widget_count_ && hidden_widget_count_ == widget_count_)
     ScheduleIdleHandler(kInitialIdleHandlerDelayMs);
 }
 
 void RenderThreadImpl::WidgetRestored() {
   DCHECK_GT(hidden_widget_count_, 0);
   hidden_widget_count_--;
-  if (!content::GetContentClient()->renderer()->
-          RunIdleHandlerWhenWidgetsHidden()) {
+  if (!GetContentClient()->renderer()->RunIdleHandlerWhenWidgetsHidden()) {
     return;
   }
 
   ScheduleIdleHandler(kLongIdleHandlerDelayMs);
 }
 
 void RenderThreadImpl::EnsureWebKitInitialized() {
   if (webkit_platform_support_.get())
     return;
 
   webkit_platform_support_.reset(new RendererWebKitPlatformSupportImpl);
   WebKit::initialize(webkit_platform_support_.get());
 
   WebKit::WebCompositorSupport* compositor_support =
       WebKit::Platform::current()->compositorSupport();
   const CommandLine& command_line = *CommandLine::ForCurrentProcess();
 
   // TODO(fsamuel): Guests don't currently support threaded compositing.
   // This should go away with the new design of the browser plugin.
   // The new design can be tracked at: http://crbug.com/134492.
   bool is_guest = CommandLine::ForCurrentProcess()->HasSwitch(
       switches::kGuestRenderer);
-  bool enable = content::IsThreadedCompositingEnabled() && !is_guest;
+  bool enable = IsThreadedCompositingEnabled() && !is_guest;
   if (enable) {
     compositor_thread_.reset(new CompositorThread(this));
     AddFilter(compositor_thread_->GetMessageFilter());
     compositor_support->initialize(compositor_thread_->GetWebThread());
   } else {
     compositor_support->initialize(NULL);
   }
   compositor_initialized_ = true;
 
   MessageLoop* output_surface_loop = enable ?
       compositor_thread_->message_loop() :
       MessageLoop::current();
 
   compositor_output_surface_filter_ = CompositorOutputSurface::CreateFilter(
       output_surface_loop->message_loop_proxy());
   AddFilter(compositor_output_surface_filter_.get());
 
   WebScriptController::enableV8SingleThreadMode();
 
   RenderThreadImpl::RegisterSchemes();
 
   webkit_glue::EnableWebCoreLogChannels(
       command_line.GetSwitchValueASCII(switches::kWebCoreLogChannels));
 
   if (CommandLine::ForCurrentProcess()->HasSwitch(
           switches::kDomAutomationController)) {
-    base::StringPiece extension = content::GetContentClient()->GetDataResource(
+    base::StringPiece extension = GetContentClient()->GetDataResource(
         IDR_DOM_AUTOMATION_JS, ui::SCALE_FACTOR_NONE);
     RegisterExtension(new v8::Extension(
         "dom_automation.js", extension.data(), 0, NULL, extension.size()));
   }
 
   web_database_observer_impl_.reset(
       new WebDatabaseObserverImpl(sync_message_filter()));
   WebKit::WebDatabase::setObserver(web_database_observer_impl_.get());
 
   WebRuntimeFeatures::enableSockets(
@@ skipping 85 matching lines @@
       command_line.HasSwitch(switches::kEnableExperimentalWebKitFeatures));
 
   WebRuntimeFeatures::enableCSSExclusions(
       command_line.HasSwitch(switches::kEnableExperimentalWebKitFeatures));
 
   FOR_EACH_OBSERVER(RenderProcessObserver, observers_, WebKitInitialized());
 
   devtools_agent_message_filter_ = new DevToolsAgentFilter();
   AddFilter(devtools_agent_message_filter_.get());
 
-  if (content::GetContentClient()->renderer()->
-         RunIdleHandlerWhenWidgetsHidden()) {
+  if (GetContentClient()->renderer()->RunIdleHandlerWhenWidgetsHidden())
     ScheduleIdleHandler(kLongIdleHandlerDelayMs);
-  }
 }
 
 void RenderThreadImpl::RegisterSchemes() {
   // swappedout: pages should not be accessible, and should also
   // be treated as empty documents that can commit synchronously.
   WebString swappedout_scheme(ASCIIToUTF16(chrome::kSwappedOutScheme));
   WebSecurityPolicy::registerURLSchemeAsDisplayIsolated(swappedout_scheme);
   WebSecurityPolicy::registerURLSchemeAsEmptyDocument(swappedout_scheme);
 }
 
@@ skipping 16 matching lines @@
 void RenderThreadImpl::ScheduleIdleHandler(int64 initial_delay_ms) {
   idle_notification_delay_in_ms_ = initial_delay_ms;
   idle_timer_.Stop();
   idle_timer_.Start(FROM_HERE,
       base::TimeDelta::FromMilliseconds(initial_delay_ms),
       this, &RenderThreadImpl::IdleHandler);
 }
 
 void RenderThreadImpl::IdleHandler() {
   bool run_in_foreground_tab = (widget_count_ > hidden_widget_count_) &&
-                               content::GetContentClient()->renderer()->
+                               GetContentClient()->renderer()->
                                    RunIdleHandlerWhenWidgetsHidden();
   if (run_in_foreground_tab) {
     IdleHandlerInForegroundTab();
     return;
   }
 
   base::allocator::ReleaseFreeMemory();
 
   v8::V8::IdleNotification();
 
@@ skipping 89 matching lines @@
     gpu_vda_context3d_.reset(
         WebGraphicsContext3DCommandBufferImpl::CreateOffscreenContext(
             this, WebKit::WebGraphicsContext3D::Attributes(),
             GURL("chrome://gpu/RenderThreadImpl::GetGpuVDAContext3D")));
     if (gpu_vda_context3d_.get())
       gpu_vda_context3d_->setContextLostCallback(context_lost_cb_.get());
   }
   return gpu_vda_context3d_.get();
 }
 
-content::AudioRendererMixerManager*
-RenderThreadImpl::GetAudioRendererMixerManager() {
+AudioRendererMixerManager* RenderThreadImpl::GetAudioRendererMixerManager() {
   if (!audio_renderer_mixer_manager_.get()) {
     audio_renderer_mixer_manager_.reset(new AudioRendererMixerManager(
         audio_hardware::GetOutputSampleRate(),
         audio_hardware::GetOutputBufferSize()));
   }
 
   return audio_renderer_mixer_manager_.get();
 }
 
 #if defined(OS_WIN)
@@ skipping 96 matching lines @@
   suspend_webkit_shared_timer_ = false;
 }
 
 void RenderThreadImpl::DoNotNotifyWebKitOfModalLoop() {
   notify_webkit_of_modal_loop_ = false;
 }
 
 void RenderThreadImpl::OnSetZoomLevelForCurrentURL(const std::string& host,
                                                    double zoom_level) {
   RenderViewZoomer zoomer(host, zoom_level);
-  content::RenderView::ForEach(&zoomer);
+  RenderView::ForEach(&zoomer);
 }
 
 bool RenderThreadImpl::OnControlMessageReceived(const IPC::Message& msg) {
   ObserverListBase<RenderProcessObserver>::Iterator it(observers_);
   RenderProcessObserver* observer;
   while ((observer = it.GetNext()) != NULL) {
     if (observer->OnControlMessageReceived(msg))
       return true;
   }
 
@@ skipping 59 matching lines @@
         false,
         params.swapped_out,
         params.next_page_id,
         params.screen_info,
         NULL,
         params.accessibility_mode);
   }
 }
 
 GpuChannelHost* RenderThreadImpl::EstablishGpuChannelSync(
-    content::CauseForGpuLaunch cause_for_gpu_launch) {
+    CauseForGpuLaunch cause_for_gpu_launch) {
   TRACE_EVENT0("gpu", "RenderThreadImpl::EstablishGpuChannelSync");
 
   if (gpu_channel_.get()) {
     // Do nothing if we already have a GPU channel or are already
     // establishing one.
     if (gpu_channel_->state() == GpuChannelHost::kUnconnected ||
         gpu_channel_->state() == GpuChannelHost::kConnected)
       return GetGpuChannel();
 
     // Recreate the channel if it has been lost.
     gpu_channel_ = NULL;
   }
 
   // Ask the browser for the channel name.
   int client_id = 0;
   IPC::ChannelHandle channel_handle;
-  content::GPUInfo gpu_info;
+  GPUInfo gpu_info;
   if (!Send(new GpuHostMsg_EstablishGpuChannel(cause_for_gpu_launch,
                                                &client_id,
                                                &channel_handle,
                                                &gpu_info)) ||
 #if defined(OS_POSIX)
       channel_handle.socket.fd == -1 ||
 #endif
       channel_handle.name.empty()) {
     // Otherwise cancel the connection.
     gpu_channel_ = NULL;
     return NULL;
   }
 
   gpu_channel_ = new GpuChannelHost(this, 0, client_id);
   gpu_channel_->set_gpu_info(gpu_info);
-  content::GetContentClient()->SetGpuInfo(gpu_info);
+  GetContentClient()->SetGpuInfo(gpu_info);
 
   // Connect to the GPU process if a channel name was received.
   gpu_channel_->Connect(channel_handle);
 
   return GetGpuChannel();
 }
 
 WebKit::WebMediaStreamCenter* RenderThreadImpl::CreateMediaStreamCenter(
     WebKit::WebMediaStreamCenterClient* client) {
 #if defined(ENABLE_WEBRTC)
   if (!media_stream_center_)
-    media_stream_center_ = new content::MediaStreamCenter(
+    media_stream_center_ = new MediaStreamCenter(
         client, GetMediaStreamDependencyFactory());
 #endif
   return media_stream_center_;
 }
 
 MediaStreamDependencyFactory*
 RenderThreadImpl::GetMediaStreamDependencyFactory() {
 #if defined(ENABLE_WEBRTC)
   if (!media_stream_factory_.get()) {
     media_stream_factory_.reset(new MediaStreamDependencyFactory(
@@ skipping 25 matching lines @@
 
   FOR_EACH_OBSERVER(RenderProcessObserver, observers_, PluginListChanged());
 }
 
 void RenderThreadImpl::OnNetworkStateChanged(bool online) {
   EnsureWebKitInitialized();
   WebNetworkStateNotifier::setOnLine(online);
 }
 
 void RenderThreadImpl::OnTempCrashWithData(const GURL& data) {
-  content::GetContentClient()->SetActiveURL(data);
+  GetContentClient()->SetActiveURL(data);
   CHECK(false);
 }
 
 scoped_refptr<base::MessageLoopProxy>
 RenderThreadImpl::GetFileThreadMessageLoopProxy() {
   DCHECK(message_loop() == MessageLoop::current());
   if (!file_thread_.get()) {
     file_thread_.reset(new base::Thread("Renderer::FILE"));
     file_thread_->Start();
   }
   return file_thread_->message_loop_proxy();
 }
+
+}  // namespace content