Revert r21117 as it caused reliability failures....

chrome/renderer/render_thread.cc

 // Copyright (c) 2009 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/render_thread.h"
 
 #include <algorithm>
 #include <vector>
 
 #include "base/command_line.h"
 #include "base/lazy_instance.h"
 #include "base/shared_memory.h"
 #include "base/stats_table.h"
 #include "base/thread_local.h"
 #include "chrome/common/app_cache/app_cache_context_impl.h"
 #include "chrome/common/app_cache/app_cache_dispatcher.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/common/render_messages.h"
 #include "chrome/common/renderer_preferences.h"
+#include "chrome/common/notification_service.h"
 #include "chrome/common/url_constants.h"
 #include "chrome/plugin/npobject_util.h"
 // TODO(port)
 #if defined(OS_WIN)
 #include "chrome/plugin/plugin_channel.h"
 #else
 #include "base/scoped_handle.h"
 #include "chrome/plugin/plugin_channel_base.h"
 #endif
 #include "chrome/renderer/devtools_agent_filter.h"
@@ skipping 17 matching lines @@
 #include "webkit/extensions/v8/playback_extension.h"
 
 #if defined(OS_WIN)
 #include <windows.h>
 #include <objbase.h>
 #endif
 
 using WebKit::WebCache;
 using WebKit::WebString;
 
-namespace {
 static const unsigned int kCacheStatsDelayMS = 2000 /* milliseconds */;
+
 static base::LazyInstance<base::ThreadLocalPointer<RenderThread> > lazy_tls(
     base::LINKER_INITIALIZED);
+
+//-----------------------------------------------------------------------------
+// Methods below are only called on the owner's thread:
+
+// When we run plugins in process, we actually run them on the render thread,
+// which means that we need to make the render thread pump UI events.
+RenderThread::RenderThread()
+    : ChildThread(
+          base::Thread::Options(RenderProcess::InProcessPlugins() ?
+              MessageLoop::TYPE_UI : MessageLoop::TYPE_DEFAULT, kV8StackSize)),
+      plugin_refresh_allowed_(true) {
+}
+
+RenderThread::RenderThread(const std::string& channel_name)
+    : ChildThread(
+          base::Thread::Options(RenderProcess::InProcessPlugins() ?
+              MessageLoop::TYPE_UI : MessageLoop::TYPE_DEFAULT, kV8StackSize)),
+      plugin_refresh_allowed_(true) {
+  SetChannelName(channel_name);
+}
+
+RenderThread::~RenderThread() {
+}
+
+RenderThread* RenderThread::current() {
+  return lazy_tls.Pointer()->Get();
+}
+
+void RenderThread::AddFilter(IPC::ChannelProxy::MessageFilter* filter) {
+  channel()->AddFilter(filter);
+}
+
+void RenderThread::RemoveFilter(IPC::ChannelProxy::MessageFilter* filter) {
+  channel()->RemoveFilter(filter);
+}
+
+void RenderThread::Resolve(const char* name, size_t length) {
+  return dns_master_->Resolve(name, length);
+}
+
+void RenderThread::SendHistograms(int sequence_number) {
+  return histogram_snapshots_->SendHistograms(sequence_number);
+}
+
 static WebAppCacheContext* CreateAppCacheContextForRenderer() {
   return new AppCacheContextImpl(RenderThread::current());
 }
 
 #if defined(OS_POSIX)
 class SuicideOnChannelErrorFilter : public IPC::ChannelProxy::MessageFilter {
   void OnChannelError() {
     // On POSIX, at least, one can install an unload handler which loops
     // forever and leave behind a renderer process which eats 100% CPU forever.
     //
     // This is because the terminate signals (ViewMsg_ShouldClose and the error
     // from the IPC channel) are routed to the main message loop but never
     // processed (because that message loop is stuck in V8).
     //
     // One could make the browser SIGKILL the renderers, but that leaves open a
     // large window where a browser failure (or a user, manually terminating
     // the browser because "it's stuck") will leave behind a process eating all
     // the CPU.
     //
     // So, we install a filter on the channel so that we can process this event
     // here and kill the process.
     _exit(0);
   }
 };
 #endif
-}  // namespace
-
-// When we run plugins in process, we actually run them on the render thread,
-// which means that we need to make the render thread pump UI events.
-RenderThread::RenderThread() {
-  Init();
-}
-
-RenderThread::RenderThread(const std::string& channel_name)
-    : ChildThread(channel_name) {
-  Init();
-}
 
 void RenderThread::Init() {
   lazy_tls.Pointer()->Set(this);
 #if defined(OS_WIN)
   // If you are running plugins in this thread you need COM active but in
   // the normal case you don't.
   if (RenderProcess::InProcessPlugins())
     CoInitialize(0);
 #endif
 
-  plugin_refresh_allowed_ = true;
+  ChildThread::Init();
+  notification_service_.reset(new NotificationService);
   cache_stats_factory_.reset(
       new ScopedRunnableMethodFactory<RenderThread>(this));
 
   visited_link_slave_.reset(new VisitedLinkSlave());
   user_script_slave_.reset(new UserScriptSlave());
   dns_master_.reset(new RenderDnsMaster());
   histogram_snapshots_.reset(new RendererHistogramSnapshots());
   app_cache_dispatcher_.reset(new AppCacheDispatcher());
   WebAppCacheContext::SetFactory(CreateAppCacheContextForRenderer);
   devtools_agent_filter_ = new DevToolsAgentFilter();
   AddFilter(devtools_agent_filter_.get());
 
 #if defined(OS_POSIX)
   suicide_on_channel_error_filter_ = new SuicideOnChannelErrorFilter;
   AddFilter(suicide_on_channel_error_filter_.get());
 #endif
 }
 
-RenderThread::~RenderThread() {
+void RenderThread::CleanUp() {
   // Shutdown in reverse of the initialization order.
   RemoveFilter(devtools_agent_filter_.get());
+  devtools_agent_filter_ = NULL;
   WebAppCacheContext::SetFactory(NULL);
-  if (webkit_client_.get())
+  app_cache_dispatcher_.reset();
+  histogram_snapshots_.reset();
+  dns_master_.reset();
+  user_script_slave_.reset();
+  visited_link_slave_.reset();
+
+  if (webkit_client_.get()) {
     WebKit::shutdown();
+    webkit_client_.reset();
+  }
 
+  notification_service_.reset();
+  ChildThread::CleanUp();
   lazy_tls.Pointer()->Set(NULL);
 
   // TODO(port)
 #if defined(OS_WIN)
   // Clean up plugin channels before this thread goes away.
   PluginChannelBase::CleanupChannels();
   // Don't call COM if the renderer is in the sandbox.
   if (RenderProcess::InProcessPlugins())
     CoUninitialize();
 #endif
 }
 
-RenderThread* RenderThread::current() {
-  return lazy_tls.Pointer()->Get();
-}
-
-void RenderThread::AddFilter(IPC::ChannelProxy::MessageFilter* filter) {
-  channel()->AddFilter(filter);
-}
-
-void RenderThread::RemoveFilter(IPC::ChannelProxy::MessageFilter* filter) {
-  channel()->RemoveFilter(filter);
-}
-
-void RenderThread::Resolve(const char* name, size_t length) {
-  return dns_master_->Resolve(name, length);
-}
-
-void RenderThread::SendHistograms(int sequence_number) {
-  return histogram_snapshots_->SendHistograms(sequence_number);
-}
-
 void RenderThread::OnUpdateVisitedLinks(base::SharedMemoryHandle table) {
   DCHECK(base::SharedMemory::IsHandleValid(table)) << "Bad table handle";
   visited_link_slave_->Init(table);
 }
 
 void RenderThread::OnAddVisitedLinks(
     const VisitedLinkSlave::Fingerprints& fingerprints) {
   for (size_t i = 0; i < fingerprints.size(); ++i)
     WebView::UpdateVisitedLinkState(fingerprints[i]);
 }
@@ skipping 66 matching lines @@
   EnsureWebKitInitialized();
 
   // When bringing in render_view, also bring in webkit's glue and jsbindings.
   base::WaitableEvent* waitable_event = new base::WaitableEvent(
 #if defined(OS_WIN)
       modal_dialog_event.event);
 #else
       true, false);
 #endif
 
+  // TODO(darin): once we have a RenderThread per RenderView, this will need to
+  // change to assert that we are not creating more than one view.
   RenderView::Create(
       this, parent_hwnd, waitable_event, MSG_ROUTING_NONE, renderer_prefs,
       webkit_prefs, new SharedRenderViewCounter(0), view_id);
 }
 
 void RenderThread::OnSetCacheCapacities(size_t min_dead_capacity,
                                         size_t max_dead_capacity,
                                         size_t capacity) {
   EnsureWebKitInitialized();
   WebCache::setCapacities(
@@ skipping 116 matching lines @@
 
 void RenderThread::OnPurgePluginListCache() {
   // The call below will cause a GetPlugins call with refresh=true, but at this
   // point we already know that the browser has refreshed its list, so disable
   // refresh temporarily to prevent each renderer process causing the list to be
   // regenerated.
   plugin_refresh_allowed_ = false;
   WebKit::resetPluginCache();
   plugin_refresh_allowed_ = true;
 }