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 61 matching lines @@
 #include "base/synchronization/lock.h"
 #include "content/common/child_process_sandbox_support_impl_linux.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/platform/linux/WebFontFamily.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/platform/linux/WebSandboxSupport.h"
 #endif
 
 #if defined(OS_POSIX)
 #include "base/file_descriptor_posix.h"
 #endif
 
+using content::RenderThread;
 using WebKit::WebAudioDevice;
 using WebKit::WebBlobRegistry;
 using WebKit::WebFileInfo;
 using WebKit::WebFileSystem;
 using WebKit::WebFrame;
 using WebKit::WebGamepads;
 using WebKit::WebIDBFactory;
 using WebKit::WebIDBKey;
 using WebKit::WebIDBKeyPath;
 using WebKit::WebKitPlatformSupport;
@@ skipping 68 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();
+  RenderThread* render_thread = RenderThread::Get();
   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(
+  RenderThread::Get()->Send(
       new ViewHostMsg_DidGenerateCacheableMetadata(url, response_time, copy));
 }
 
 WebString RendererWebKitPlatformSupportImpl::defaultLocale() {
-  return ASCIIToUTF16(RenderThreadImpl::Get()->GetLocale());
+  return ASCIIToUTF16(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();
+  RenderThread* thread = 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(
+  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(
+  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(
+  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);
+  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 (!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 160 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(
+  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(
+  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(
+  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();
 }