Speculative Revert of 185945

Looks like this caused perf regressions on both dual- and single-core Win7 perf
bots:
http://chromium-perf.appspot.com/?tab=chromium-rel-win7-dual&graph=times&rev=186115&history=150&master=ChromiumPerf&testSuite=page_cycler_moz&details=true

> Remove CompositorThread dependency on WebThread
> 
> content:: creates and manages the compositor thread itself, it doesn't need to
> use a WebThread type or use WebCompositorSupport to manage threaded-ness. This
> cuts the dependency of content::CompositorThread to just depend on base::Thread.
> The message loop is bound to in content::RenderWidgetCompositor.
> 
> 
> Review URL: https://chromiumcodereview.appspot.com/12386078

TBR=jamesr@chromium.org
Review URL: https://codereview.chromium.org/12390068

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@185987 0039d316-1c4b-4281-b951-d872f2087c98

6 files changed, 29 insertions, 25 deletions

diff --git a/content/renderer/gpu/compositor_thread.cc b/content/renderer/gpu/compositor_thread.cc
index 7497b26..cde2e93 100644
--- a/content/renderer/gpu/compositor_thread.cc
+++ b/content/renderer/gpu/compositor_thread.cc
@@ -100,7 +100,6 @@ void SetHighThreadPriority() {
 
 CompositorThread::CompositorThread(IPC::Listener* main_listener)
     : thread_("Compositor") {
-  thread_.Start();
   filter_ =
       new InputEventFilter(main_listener,
                            thread_.message_loop()->message_loop_proxy(),
@@ -162,11 +161,6 @@ void CompositorThread::AddInputHandlerOnCompositorThread(
           routing_id, input_handler, main_loop, render_view_impl));
 }
 
-
-base::MessageLoopProxy* CompositorThread::message_loop_proxy() const {
-  return thread_.message_loop()->message_loop_proxy();
-}
-
 void CompositorThread::RemoveInputHandler(int routing_id) {
   DCHECK_EQ(MessageLoop::current(), thread_.message_loop());
 
diff --git a/content/renderer/gpu/compositor_thread.h b/content/renderer/gpu/compositor_thread.h
index 1319267..e0bc9f3 100644
--- a/content/renderer/gpu/compositor_thread.h
+++ b/content/renderer/gpu/compositor_thread.h
@@ -9,9 +9,9 @@
 
 #include "base/memory/ref_counted.h"
 #include "base/memory/weak_ptr.h"
-#include "base/threading/thread.h"
 #include "content/renderer/render_view_impl.h"
 #include "ipc/ipc_channel_proxy.h"
+#include "webkit/glue/webthread_impl.h"
 
 namespace WebKit {
 class WebInputEvent;
@@ -40,7 +40,9 @@ class CompositorThread {
                        int input_handler_id,
                        const base::WeakPtr<RenderViewImpl>& render_view_impl);
 
-  base::MessageLoopProxy* message_loop_proxy() const;
+  webkit_glue::WebThreadImpl* GetWebThread() { return &thread_; }
+
+  MessageLoop* message_loop() { return thread_.message_loop(); }
 
  private:
   // Callback only from the compositor's thread.
@@ -64,7 +66,7 @@ class CompositorThread {
                    scoped_refptr<InputHandlerWrapper> > InputHandlerMap;
   InputHandlerMap input_handlers_;
 
-  base::Thread thread_;
+  webkit_glue::WebThreadImpl thread_;
   scoped_refptr<InputEventFilter> filter_;
 };
 
diff --git a/content/renderer/gpu/render_widget_compositor.cc b/content/renderer/gpu/render_widget_compositor.cc
index ddb1c82..1fc1321 100644
--- a/content/renderer/gpu/render_widget_compositor.cc
+++ b/content/renderer/gpu/render_widget_compositor.cc
@@ -276,7 +276,7 @@ bool RenderWidgetCompositor::initialize(cc::LayerTreeSettings settings) {
   threaded_ = !!compositor_thread;
   if (compositor_thread)
     impl_thread = cc::ThreadImpl::createForDifferentThread(
-        compositor_thread->message_loop_proxy());
+        compositor_thread->message_loop()->message_loop_proxy());
   layer_tree_host_ = cc::LayerTreeHost::create(this,
                                                settings,
                                                impl_thread.Pass());
diff --git a/content/renderer/render_thread_impl.cc b/content/renderer/render_thread_impl.cc
index bee6fc1..d9eaf18 100644
--- a/content/renderer/render_thread_impl.cc
+++ b/content/renderer/render_thread_impl.cc
@@ -322,6 +322,7 @@ void RenderThreadImpl::Init() {
   idle_notification_delay_in_ms_ = kInitialIdleHandlerDelayMs;
   idle_notifications_to_skip_ = 0;
   require_user_gesture_for_focus_ = true;
+  compositor_initialized_ = false;
 
   appcache_dispatcher_.reset(new AppCacheDispatcher(Get()));
   dom_storage_dispatcher_.reset(new DomStorageDispatcher());
@@ -408,6 +409,10 @@ RenderThreadImpl::~RenderThreadImpl() {
     compositor_output_surface_filter_ = NULL;
   }
 
+  if (compositor_initialized_) {
+    WebKit::Platform::current()->compositorSupport()->shutdown();
+    compositor_initialized_ = false;
+  }
   if (compositor_thread_.get()) {
     RemoveFilter(compositor_thread_->GetMessageFilter());
     compositor_thread_.reset();
@@ -594,22 +599,26 @@ void RenderThreadImpl::EnsureWebKitInitialized() {
   WebKit::setIDBFactory(
       webkit_platform_support_.get()->idbFactory());
 
+  WebKit::WebCompositorSupport* compositor_support =
+      WebKit::Platform::current()->compositorSupport();
   const CommandLine& command_line = *CommandLine::ForCurrentProcess();
 
   bool enable = command_line.HasSwitch(switches::kEnableThreadedCompositing);
   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;
 
-  base::MessageLoopProxy* output_surface_loop;
-  if (enable)
-    output_surface_loop = compositor_thread_->message_loop_proxy();
-  else
-    output_surface_loop = base::MessageLoopProxy::current();
+  MessageLoop* output_surface_loop = enable ?
+      compositor_thread_->message_loop() :
+      MessageLoop::current();
 
-  compositor_output_surface_filter_ =
-      CompositorOutputSurface::CreateFilter(output_surface_loop);
+  compositor_output_surface_filter_ = CompositorOutputSurface::CreateFilter(
+      output_surface_loop->message_loop_proxy());
   AddFilter(compositor_output_surface_filter_.get());
 
   WebScriptController::enableV8SingleThreadMode();
@@ -876,7 +885,7 @@ void RenderThreadImpl::OnGpuVDAContextLoss() {
   if (!self->gpu_vda_context3d_.get())
     return;
   if (self->compositor_thread()) {
-    self->compositor_thread()->message_loop_proxy()->DeleteSoon(
+    self->compositor_thread()->GetWebThread()->message_loop()->DeleteSoon(
         FROM_HERE, self->gpu_vda_context3d_.release());
   } else {
     self->gpu_vda_context3d_.reset();
diff --git a/content/renderer/render_thread_impl.h b/content/renderer/render_thread_impl.h
index 49235e0..9813cfb 100644
--- a/content/renderer/render_thread_impl.h
+++ b/content/renderer/render_thread_impl.h
@@ -392,6 +392,7 @@ class CONTENT_EXPORT RenderThreadImpl : public RenderThread,
   // A lazily initiated thread on which file operations are run.
   scoped_ptr<base::Thread> file_thread_;
 
+  bool compositor_initialized_;
   scoped_ptr<CompositorThread> compositor_thread_;
   scoped_refptr<IPC::ForwardingMessageFilter> compositor_output_surface_filter_;
 
diff --git a/content/renderer/render_view_impl.cc b/content/renderer/render_view_impl.cc
index e29914a..ef24312 100644
--- a/content/renderer/render_view_impl.cc
+++ b/content/renderer/render_view_impl.cc
@@ -2781,13 +2781,11 @@ WebMediaPlayer* RenderViewImpl::createMediaPlayer(
   if (!cmd_line->HasSwitch(switches::kDisableAcceleratedVideoDecode))
     context3d = RenderThreadImpl::current()->GetGpuVDAContext3D();
   if (context3d) {
-    scoped_refptr<base::MessageLoopProxy> factories_loop;
-    CompositorThread* compositor_thread =
-        RenderThreadImpl::current()->compositor_thread();
-    if (compositor_thread)
-      factories_loop = compositor_thread->message_loop_proxy();
-    else
-      factories_loop = base::MessageLoopProxy::current();
+    scoped_refptr<base::MessageLoopProxy> factories_loop =
+        RenderThreadImpl::current()->compositor_thread() ?
+        RenderThreadImpl::current()->compositor_thread()->GetWebThread()
+            ->message_loop()->message_loop_proxy() :
+        base::MessageLoopProxy::current();
     GpuChannelHost* gpu_channel_host =
         RenderThreadImpl::current()->EstablishGpuChannelSync(
             CAUSE_FOR_GPU_LAUNCH_VIDEODECODEACCELERATOR_INITIALIZE);