Mac: move content::RenderWidgetResizeHelper to ui::WindowResizeHelperMac (acelerated_widget_mac)

ui/accelerated_widget_mac/window_resize_helper_mac.cc

Index: ui/accelerated_widget_mac/window_resize_helper_mac.cc
diff --git a/content/browser/renderer_host/render_widget_resize_helper_mac.cc b/ui/accelerated_widget_mac/window_resize_helper_mac.cc
similarity index 76%
copy from content/browser/renderer_host/render_widget_resize_helper_mac.cc
copy to ui/accelerated_widget_mac/window_resize_helper_mac.cc
index 823c6848602586e12be00b7b75c18ccdbda1aa58..f36aa91dcc4680672acc5898746015f4ea19659b 100644
--- a/content/browser/renderer_host/render_widget_resize_helper_mac.cc
+++ b/ui/accelerated_widget_mac/window_resize_helper_mac.cc
@@ -1,16 +1,19 @@
-// Copyright 2014 The Chromium Authors. All rights reserved.
+// Copyright 2015 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/browser/renderer_host/render_widget_resize_helper_mac.h"
+#include "ui/accelerated_widget_mac/window_resize_helper_mac.h"
 
 #include <list>
 
-#include "content/browser/gpu/gpu_process_host_ui_shim.h"
-#include "content/browser/renderer_host/render_process_host_impl.h"
-#include "content/public/browser/browser_thread.h"
+#include "base/bind.h"
+#include "base/callback.h"
+#include "base/single_thread_task_runner.h"
+#include "base/synchronization/lock.h"
+#include "base/synchronization/waitable_event.h"
+#include "base/threading/thread_restrictions.h"
 
-namespace content {
+namespace ui {
 namespace {
 
 class WrappedTask;
@@ -53,8 +56,9 @@ class WrappedTask {
 // WaitForSingleWrappedTaskToRun call or through the target task runner.
 class PumpableTaskRunner : public base::SingleThreadTaskRunner {
  public:
-  explicit PumpableTaskRunner(
-      const EventTimedWaitCallback& event_timed_wait_callback);
+  PumpableTaskRunner(
+      const EventTimedWaitCallback& event_timed_wait_callback,
+      const scoped_refptr<base::SingleThreadTaskRunner>& target_task_runner);
 
   // Enqueue WrappedTask and post it to |target_task_runner_|.
   bool EnqueueAndPostWrappedTask(const tracked_objects::Location& from_here,
@@ -64,9 +68,6 @@ class PumpableTaskRunner : public base::SingleThreadTaskRunner {
   // Wait at most |max_delay| to run an enqueued task.
   bool WaitForSingleWrappedTaskToRun(const base::TimeDelta& max_delay);
 
-  // Remove a wrapped task from the queue.
-  void RemoveWrappedTaskFromQueue(WrappedTask* task);
-
   // base::SingleThreadTaskRunner implementation:
   bool PostDelayedTask(const tracked_objects::Location& from_here,
                        const base::Closure& task,
@@ -103,19 +104,7 @@ class PumpableTaskRunner : public base::SingleThreadTaskRunner {
   DISALLOW_COPY_AND_ASSIGN(PumpableTaskRunner);
 };
 
-void HandleGpuIPC(int gpu_host_id, const IPC::Message& message) {
-  GpuProcessHostUIShim* host = GpuProcessHostUIShim::FromID(gpu_host_id);
-  if (host)
-    host->OnMessageReceived(message);
-}
-
-void HandleRendererIPC(int render_process_id, const IPC::Message& message) {
-  RenderProcessHost* host = RenderProcessHost::FromID(render_process_id);
-  if (host)
-    host->OnMessageReceived(message);
-}
-
-base::LazyInstance<RenderWidgetResizeHelper> g_render_widget_task_runner =
+base::LazyInstance<WindowResizeHelperMac>::Leaky g_window_resize_helper =
     LAZY_INSTANCE_INITIALIZER;
 
 ////////////////////////////////////////////////////////////////////////////////
@@ -181,11 +170,11 @@ void WrappedTask::RemoveFromTaskRunnerQueue() {
 // PumpableTaskRunner
 
 PumpableTaskRunner::PumpableTaskRunner(
-    const EventTimedWaitCallback& event_timed_wait_callback)
+    const EventTimedWaitCallback& event_timed_wait_callback,
+    const scoped_refptr<base::SingleThreadTaskRunner>& target_task_runner)
     : event_(false /* auto-reset */, false /* initially signalled */),
       event_timed_wait_callback_(event_timed_wait_callback),
-      target_task_runner_(
-          BrowserThread::GetMessageLoopProxyForThread(BrowserThread::UI)) {}
+      target_task_runner_(target_task_runner) {}
 
 PumpableTaskRunner::~PumpableTaskRunner() {
   // Because tasks hold a reference to the task runner, the task queue must
@@ -289,57 +278,41 @@ bool PumpableTaskRunner::RunsTasksOnCurrentThread() const {
 }  // namespace
 
 ////////////////////////////////////////////////////////////////////////////////
-// RenderWidgetResizeHelper
+// WindowResizeHelperMac
 
-scoped_refptr<base::SingleThreadTaskRunner>
-RenderWidgetResizeHelper::task_runner() const {
+scoped_refptr<base::SingleThreadTaskRunner> WindowResizeHelperMac::task_runner()
+    const {
   return task_runner_;
 }
 
 // static
-RenderWidgetResizeHelper* RenderWidgetResizeHelper::Get() {
-  return g_render_widget_task_runner.Pointer();
+WindowResizeHelperMac* WindowResizeHelperMac::Get() {
+  return g_window_resize_helper.Pointer();
 }
 
-bool RenderWidgetResizeHelper::WaitForSingleTaskToRun(
-    const base::TimeDelta& max_delay) {
-  PumpableTaskRunner* pumpable_task_runner =
-      reinterpret_cast<PumpableTaskRunner*>(task_runner_.get());
-  return pumpable_task_runner->WaitForSingleWrappedTaskToRun(max_delay);
+void WindowResizeHelperMac::Init(
+    const scoped_refptr<base::SingleThreadTaskRunner>& target_task_runner) {
+  DCHECK(!task_runner_);
+  task_runner_ = new PumpableTaskRunner(
+      base::Bind(&WindowResizeHelperMac::EventTimedWait), target_task_runner);
 }
 
-void RenderWidgetResizeHelper::PostRendererProcessMsg(int render_process_id,
-                                                      const IPC::Message& msg) {
-  PumpableTaskRunner* pumpable_task_runner =
-      reinterpret_cast<PumpableTaskRunner*>(task_runner_.get());
-  pumpable_task_runner->EnqueueAndPostWrappedTask(
-      FROM_HERE,
-      new WrappedTask(base::Bind(HandleRendererIPC, render_process_id, msg),
-                      base::TimeDelta()),
-      base::TimeDelta());
-}
-
-void RenderWidgetResizeHelper::PostGpuProcessMsg(int gpu_host_id,
-                                                 const IPC::Message& msg) {
+bool WindowResizeHelperMac::WaitForSingleTaskToRun(
+    const base::TimeDelta& max_delay) {
   PumpableTaskRunner* pumpable_task_runner =
-      reinterpret_cast<PumpableTaskRunner*>(task_runner_.get());
-  pumpable_task_runner->EnqueueAndPostWrappedTask(
-      FROM_HERE, new WrappedTask(base::Bind(HandleGpuIPC, gpu_host_id, msg),
-                                 base::TimeDelta()),
-      base::TimeDelta());
-}
-
-RenderWidgetResizeHelper::RenderWidgetResizeHelper() {
-  task_runner_ = new PumpableTaskRunner(base::Bind(&EventTimedWait));
+      static_cast<PumpableTaskRunner*>(task_runner_.get());
+  if (!pumpable_task_runner)
+    return false;
+  return pumpable_task_runner->WaitForSingleWrappedTaskToRun(max_delay);
 }
 
-RenderWidgetResizeHelper::~RenderWidgetResizeHelper() {}
+WindowResizeHelperMac::WindowResizeHelperMac() {}
+WindowResizeHelperMac::~WindowResizeHelperMac() {}
 
-// static
-void RenderWidgetResizeHelper::EventTimedWait(base::WaitableEvent* event,
-                                              base::TimeDelta delay) {
+void WindowResizeHelperMac::EventTimedWait(base::WaitableEvent* event,
+                                           base::TimeDelta delay) {
   base::ThreadRestrictions::ScopedAllowWait allow_wait;
   event->TimedWait(delay);
 }
 
-}  // namespace content
+}  // namespace ui