Rename RenderThread to RenderThreadImpl

content/renderer/renderer_webkitplatformsupport_impl.cc

 // Copyright (c) 2011 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/renderer_webkitplatformsupport_impl.h"
 
 #include "base/command_line.h"
 #include "base/file_path.h"
 #include "base/file_util.h"
 #include "base/platform_file.h"
 #include "base/shared_memory.h"
 #include "base/utf_string_conversions.h"
 #include "content/common/content_switches.h"
 #include "content/common/database_util.h"
 #include "content/common/file_system/webfilesystem_impl.h"
 #include "content/common/file_utilities_messages.h"
 #include "content/common/mime_registry_messages.h"
 #include "content/common/npobject_util.h"
 #include "content/common/view_messages.h"
 #include "content/common/webblobregistry_impl.h"
 #include "content/common/webmessageportchannel_impl.h"
 #include "content/public/renderer/content_renderer_client.h"
 #include "content/renderer/gpu/webgraphicscontext3d_command_buffer_impl.h"
 #include "content/renderer/media/audio_device.h"
-#include "content/renderer/render_thread.h"
+#include "content/renderer/render_thread_impl.h"
 #include "content/renderer/render_view.h"
 #include "content/renderer/renderer_webaudiodevice_impl.h"
 #include "content/renderer/renderer_webidbfactory_impl.h"
 #include "content/renderer/renderer_webstoragenamespace_impl.h"
 #include "content/renderer/websharedworkerrepository_impl.h"
 #include "googleurl/src/gurl.h"
 #include "ipc/ipc_sync_message_filter.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebBlobRegistry.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebFrame.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebGraphicsContext3D.h"
@@ skipping 149 matching lines @@
   // Even if the sandbox is disabled, there's no reason why the code should
   // act any differently...unless we're in single process mode.  In which
   // case, we have no other choice.  WebKitPlatformSupport.h discourages using
   // this switch unless absolutely necessary, so hopefully we won't end up
   // with too many code paths being different in single-process mode.
   return !CommandLine::ForCurrentProcess()->HasSwitch(switches::kSingleProcess);
 }
 
 bool RendererWebKitPlatformSupportImpl::SendSyncMessageFromAnyThread(
     IPC::SyncMessage* msg) {
-  RenderThread* render_thread = RenderThread::current();
+  RenderThreadImpl* render_thread = RenderThreadImpl::current();
   if (render_thread)
     return render_thread->Send(msg);
 
   scoped_refptr<IPC::SyncMessageFilter> sync_msg_filter(
       ChildThread::current()->sync_message_filter());
   return sync_msg_filter->Send(msg);
 }
 
 unsigned long long RendererWebKitPlatformSupportImpl::visitedLinkHash(
     const char* canonical_url,
@@ skipping 40 matching lines @@
     double response_time,
     const char* data,
     size_t size) {
   if (!CheckPreparsedJsCachingEnabled())
     return;
 
   // Let the browser know we generated cacheable metadata for this resource. The
   // browser may cache it and return it on subsequent responses to speed
   // the processing of this resource.
   std::vector<char> copy(data, data + size);
-  RenderThread::current()->Send(new ViewHostMsg_DidGenerateCacheableMetadata(
-      url, response_time, copy));
+  RenderThreadImpl::current()->Send(
+      new ViewHostMsg_DidGenerateCacheableMetadata(url, response_time, copy));
 }
 
 WebString RendererWebKitPlatformSupportImpl::defaultLocale() {
-  return ASCIIToUTF16(RenderThread::Get()->GetLocale());
+  return ASCIIToUTF16(RenderThreadImpl::Get()->GetLocale());
 }
 
 void RendererWebKitPlatformSupportImpl::suddenTerminationChanged(bool enabled) {
   if (enabled) {
     // We should not get more enables than disables, but we want it to be a
     // non-fatal error if it does happen.
     DCHECK_GT(sudden_termination_disables_, 0);
     sudden_termination_disables_ = std::max(sudden_termination_disables_ - 1,
                                             0);
     if (sudden_termination_disables_ != 0)
       return;
   } else {
     sudden_termination_disables_++;
     if (sudden_termination_disables_ != 1)
       return;
   }
 
-  RenderThread* thread = RenderThread::current();
+  RenderThreadImpl* thread = RenderThreadImpl::current();
   if (thread)  // NULL in unittests.
     thread->Send(new ViewHostMsg_SuddenTerminationChanged(enabled));
 }
 
 WebStorageNamespace*
 RendererWebKitPlatformSupportImpl::createLocalStorageNamespace(
     const WebString& path, unsigned quota) {
   if (CommandLine::ForCurrentProcess()->HasSwitch(switches::kSingleProcess))
     return WebStorageNamespace::createLocalStorageNamespace(path, quota);
   return new RendererWebStorageNamespaceImpl(DOM_STORAGE_LOCAL);
@@ skipping 58 matching lines @@
 
 WebString
 RendererWebKitPlatformSupportImpl::MimeRegistry::mimeTypeForExtension(
     const WebString& file_extension) {
   if (IsPluginProcess())
     return SimpleWebMimeRegistryImpl::mimeTypeForExtension(file_extension);
 
   // The sandbox restricts our access to the registry, so we need to proxy
   // these calls over to the browser process.
   std::string mime_type;
-  RenderThread::current()->Send(
+  RenderThreadImpl::current()->Send(
       new MimeRegistryMsg_GetMimeTypeFromExtension(
           webkit_glue::WebStringToFilePathString(file_extension), &mime_type));
   return ASCIIToUTF16(mime_type);
 
 }
 
 WebString RendererWebKitPlatformSupportImpl::MimeRegistry::mimeTypeFromFile(
     const WebString& file_path) {
   if (IsPluginProcess())
     return SimpleWebMimeRegistryImpl::mimeTypeFromFile(file_path);
 
   // The sandbox restricts our access to the registry, so we need to proxy
   // these calls over to the browser process.
   std::string mime_type;
-  RenderThread::current()->Send(new MimeRegistryMsg_GetMimeTypeFromFile(
+  RenderThreadImpl::current()->Send(new MimeRegistryMsg_GetMimeTypeFromFile(
       FilePath(webkit_glue::WebStringToFilePathString(file_path)),
       &mime_type));
   return ASCIIToUTF16(mime_type);
 
 }
 
 WebString
 RendererWebKitPlatformSupportImpl::MimeRegistry::preferredExtensionForMIMEType(
     const WebString& mime_type) {
   if (IsPluginProcess())
     return SimpleWebMimeRegistryImpl::preferredExtensionForMIMEType(mime_type);
 
   // The sandbox restricts our access to the registry, so we need to proxy
   // these calls over to the browser process.
   FilePath::StringType file_extension;
-  RenderThread::current()->Send(
+  RenderThreadImpl::current()->Send(
       new MimeRegistryMsg_GetPreferredExtensionForMimeType(
           UTF16ToASCII(mime_type), &file_extension));
   return webkit_glue::FilePathStringToWebString(file_extension);
 }
 
 //------------------------------------------------------------------------------
 
 bool RendererWebKitPlatformSupportImpl::FileUtilities::getFileSize(
     const WebString& path, long long& result) {
   if (SendSyncMessageFromAnyThread(new FileUtilitiesMsg_GetFileSize(
           webkit_glue::WebStringToFilePath(path),
           reinterpret_cast<int64*>(&result)))) {
     return result >= 0;
   }
 
   result = -1;
   return false;
 }
 
 void RendererWebKitPlatformSupportImpl::FileUtilities::revealFolderInOS(
     const WebString& path) {
   FilePath file_path(webkit_glue::WebStringToFilePath(path));
   file_util::AbsolutePath(&file_path);
-  RenderThread::current()->Send(new ViewHostMsg_RevealFolderInOS(file_path));
+  RenderThreadImpl::current()->Send(
+      new ViewHostMsg_RevealFolderInOS(file_path));
 }
 
 bool RendererWebKitPlatformSupportImpl::FileUtilities::getFileModificationTime(
     const WebString& path,
     double& result) {
   base::Time time;
   if (SendSyncMessageFromAnyThread(new FileUtilitiesMsg_GetFileModificationTime(
           webkit_glue::WebStringToFilePath(path), &time))) {
     result = time.ToDoubleT();
     return !time.is_null();
@@ skipping 13 matching lines @@
 }
 
 //------------------------------------------------------------------------------
 
 #if defined(OS_WIN)
 
 bool RendererWebKitPlatformSupportImpl::SandboxSupport::ensureFontLoaded(
     HFONT font) {
   LOGFONT logfont;
   GetObject(font, sizeof(LOGFONT), &logfont);
-  RenderThread::current()->PreCacheFont(logfont);
+  RenderThreadImpl::current()->PreCacheFont(logfont);
   return true;
 }
 
 #elif defined(OS_MACOSX)
 
 bool RendererWebKitPlatformSupportImpl::SandboxSupport::loadFont(
     NSFont* src_font, CGFontRef* out, uint32* font_id) {
   uint32 font_data_size;
   FontDescriptor src_font_descriptor(src_font);
   base::SharedMemoryHandle font_data;
-  if (!RenderThread::current()->Send(new ViewHostMsg_LoadFont(
+  if (!RenderThreadImpl::current()->Send(new ViewHostMsg_LoadFont(
         src_font_descriptor, &font_data_size, &font_data, font_id))) {
     *out = NULL;
     *font_id = 0;
     return false;
   }
 
   if (font_data_size == 0 || font_data == base::SharedMemory::NULLHandle() ||
       *font_id == 0) {
     NOTREACHED() << "Bad response from ViewHostMsg_LoadFont() for " <<
         src_font_descriptor.font_name;
@@ skipping 116 matching lines @@
 }
 
 //------------------------------------------------------------------------------
 
 WebKit::WebString
 RendererWebKitPlatformSupportImpl::signedPublicKeyAndChallengeString(
     unsigned key_size_index,
     const WebKit::WebString& challenge,
     const WebKit::WebURL& url) {
   std::string signed_public_key;
-  RenderThread::current()->Send(new ViewHostMsg_Keygen(
+  RenderThreadImpl::current()->Send(new ViewHostMsg_Keygen(
       static_cast<uint32>(key_size_index),
       challenge.utf8(),
       GURL(url),
       &signed_public_key));
   return WebString::fromUTF8(signed_public_key);
 }
 
 //------------------------------------------------------------------------------
 
 WebBlobRegistry* RendererWebKitPlatformSupportImpl::blobRegistry() {
-  // RenderThread::current can be NULL when running some tests.
-  if (!blob_registry_.get() && RenderThread::current()) {
-    blob_registry_.reset(new WebBlobRegistryImpl(RenderThread::Get()));
+  // RenderThreadImpl::current can be NULL when running some tests.
+  if (!blob_registry_.get() && RenderThreadImpl::current()) {
+    blob_registry_.reset(new WebBlobRegistryImpl(RenderThreadImpl::Get()));
   }
   return blob_registry_.get();
 }