Make plugins work in a RenderViewTest

content/renderer/renderer_webkitplatformsupport_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/renderer_webkitplatformsupport_impl.h"
 
 #include "base/command_line.h"
 #include "base/file_path.h"
 #include "base/file_util.h"
 #include "base/metrics/histogram.h"
@@ skipping 149 matching lines @@
 };
 #endif  // defined(OS_ANDROID)
 
 //------------------------------------------------------------------------------
 
 RendererWebKitPlatformSupportImpl::RendererWebKitPlatformSupportImpl()
     : clipboard_client_(new RendererClipboardClient),
       clipboard_(new webkit_glue::WebClipboardImpl(clipboard_client_.get())),
       mime_registry_(new RendererWebKitPlatformSupportImpl::MimeRegistry),
       sudden_termination_disables_(0),
+      plugin_refresh_allowed_(true),
       shared_worker_repository_(new WebSharedWorkerRepositoryImpl) {
   if (g_sandbox_enabled) {
     sandbox_support_.reset(
         new RendererWebKitPlatformSupportImpl::SandboxSupport);
   } else {
     DVLOG(1) << "Disabling sandbox support for testing.";
   }
 }
 
 RendererWebKitPlatformSupportImpl::~RendererWebKitPlatformSupportImpl() {
 }
 
 //------------------------------------------------------------------------------
 
 namespace {
 
 bool SendSyncMessageFromAnyThreadInternal(IPC::SyncMessage* msg) {
-  RenderThreadImpl* render_thread = RenderThreadImpl::current();
+  content::RenderThread* render_thread = content::RenderThread::Get();

[jam, 2012/07/31 20:05:07]

nit: just do a "using content::RenderThread" at the top. it'll make this easier
to read, and this code should move into the content namespace anyways in the
future.

[Fady Samuel, 2012/07/31 20:20:59]

Done.

   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);
 }
 
 bool SendSyncMessageFromAnyThread(IPC::SyncMessage* msg) {
   base::TimeTicks begin = base::TimeTicks::Now();
   const bool success = SendSyncMessageFromAnyThreadInternal(msg);
@@ skipping 91 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);
-  RenderThreadImpl::current()->Send(
+  content::RenderThread::Get()->Send(
       new ViewHostMsg_DidGenerateCacheableMetadata(url, response_time, copy));
 }
 
 WebString RendererWebKitPlatformSupportImpl::defaultLocale() {
-  return ASCIIToUTF16(RenderThreadImpl::Get()->GetLocale());
+  return ASCIIToUTF16(content::RenderThread::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;
   }
 
-  RenderThreadImpl* thread = RenderThreadImpl::current();
+  content::RenderThread* thread = content::RenderThread::Get();
   if (thread)  // NULL in unittests.
     thread->Send(new ViewHostMsg_SuddenTerminationChanged(enabled));
 }
 
 WebStorageNamespace*
 RendererWebKitPlatformSupportImpl::createLocalStorageNamespace(
     const WebString& path, unsigned quota) {
   return new WebStorageNamespaceImpl();
 }
 
@@ skipping 45 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;
-  RenderThreadImpl::current()->Send(
+  content::RenderThread::Get()->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;
-  RenderThreadImpl::current()->Send(new MimeRegistryMsg_GetMimeTypeFromFile(
+  content::RenderThread::Get()->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;
-  RenderThreadImpl::current()->Send(
+  content::RenderThread::Get()->Send(
       new MimeRegistryMsg_GetPreferredExtensionForMimeType(
           UTF16ToASCII(mime_type), &file_extension));
   return webkit_glue::FilePathStringToWebString(file_extension);
 }
 
 //------------------------------------------------------------------------------
 
 bool RendererWebKitPlatformSupportImpl::FileUtilities::getFileInfo(
     const WebString& path,
     WebFileInfo& web_file_info) {
@@ skipping 19 matching lines @@
 }
 
 //------------------------------------------------------------------------------
 
 #if defined(OS_WIN)
 
 bool RendererWebKitPlatformSupportImpl::SandboxSupport::ensureFontLoaded(
     HFONT font) {
   LOGFONT logfont;
   GetObject(font, sizeof(LOGFONT), &logfont);
-  RenderThreadImpl::current()->PreCacheFont(logfont);
+  content::RenderThread::Get()->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 (!RenderThreadImpl::current()->Send(new ViewHostMsg_LoadFont(
+  if (!content::RenderThread::Get()->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) {
     LOG(ERROR) << "Bad response from ViewHostMsg_LoadFont() for " <<
         src_font_descriptor.font_name;
@@ skipping 82 matching lines @@
 RendererWebKitPlatformSupportImpl::sharedWorkerRepository() {
   if (!CommandLine::ForCurrentProcess()->HasSwitch(
           switches::kDisableSharedWorkers)) {
     return shared_worker_repository_.get();
   } else {
     return NULL;
   }
 }
 
 bool RendererWebKitPlatformSupportImpl::canAccelerate2dCanvas() {
   RenderThreadImpl* thread = RenderThreadImpl::current();

[jam, 2012/07/31 20:05:07]

what about here and the few usages below of RenderThreadImpl? if someone writes
a RenderViewTest and these end up being called, things will still blow up.

you dont have to fix it now, since this existed before, but this seems like
something that'll bite us again.

[Fady Samuel, 2012/07/31 20:20:59]

Added TODOs.

   GpuChannelHost* host = thread->EstablishGpuChannelSync(
       content::CAUSE_FOR_GPU_LAUNCH_CANVAS_2D);
   if (!host)
     return false;
 
   const content::GPUInfo& gpu_info = host->gpu_info();
   if (gpu_info.can_lose_context || gpu_info.software_rendering)
     return false;
 
   return true;
@@ skipping 57 matching lines @@
 }
 
 //------------------------------------------------------------------------------
 
 WebKit::WebString
 RendererWebKitPlatformSupportImpl::signedPublicKeyAndChallengeString(
     unsigned key_size_index,
     const WebKit::WebString& challenge,
     const WebKit::WebURL& url) {
   std::string signed_public_key;
-  RenderThreadImpl::current()->Send(new ViewHostMsg_Keygen(
+  content::RenderThread::Get()->Send(new ViewHostMsg_Keygen(
       static_cast<uint32>(key_size_index),
       challenge.utf8(),
       GURL(url),
       &signed_public_key));
   return WebString::fromUTF8(signed_public_key);
 }
 
 //------------------------------------------------------------------------------
 
 void RendererWebKitPlatformSupportImpl::screenColorProfile(
     WebVector<char>* to_profile) {
   std::vector<char> profile;
-  RenderThreadImpl::current()->Send(
+  content::RenderThread::Get()->Send(
       new ViewHostMsg_GetMonitorColorProfile(&profile));
   *to_profile = profile;
 }
 
 //------------------------------------------------------------------------------
 
 WebBlobRegistry* RendererWebKitPlatformSupportImpl::blobRegistry() {
   // ChildThread::current can be NULL when running some tests.
   if (!blob_registry_.get() && ChildThread::current()) {
     blob_registry_.reset(new WebBlobRegistryImpl(ChildThread::current()));
   }
   return blob_registry_.get();
 }
 
 //------------------------------------------------------------------------------
 
 void RendererWebKitPlatformSupportImpl::sampleGamepads(WebGamepads& gamepads) {
   if (!gamepad_shared_memory_reader_.get())
     gamepad_shared_memory_reader_.reset(new content::GamepadSharedMemoryReader);
   gamepad_shared_memory_reader_->SampleGamepads(gamepads);
 }
 
 WebKit::WebString RendererWebKitPlatformSupportImpl::userAgent(
     const WebKit::WebURL& url) {
  return WebKitPlatformSupportImpl::userAgent(url);
 }
 
 void RendererWebKitPlatformSupportImpl::GetPlugins(
     bool refresh, std::vector<webkit::WebPluginInfo>* plugins) {
-  if (!RenderThreadImpl::current()->plugin_refresh_allowed())
+  if (!plugin_refresh_allowed())
     refresh = false;
-  RenderThreadImpl::current()->Send(
+  content::RenderThread::Get()->Send(
       new ViewHostMsg_GetPlugins(refresh, plugins));
 }
 
 //------------------------------------------------------------------------------
 
 WebPeerConnection00Handler*
 RendererWebKitPlatformSupportImpl::createPeerConnection00Handler(
     WebPeerConnection00HandlerClient* client) {
   WebFrame* web_frame = WebFrame::frameForCurrentContext();
   if (!web_frame)
@@ skipping 21 matching lines @@
     bool enable) {
   bool was_enabled = g_sandbox_enabled;
   g_sandbox_enabled = enable;
   return was_enabled;
 }
 
 GpuChannelHostFactory*
 RendererWebKitPlatformSupportImpl::GetGpuChannelHostFactory() {
   return RenderThreadImpl::current();
 }