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

ui/accelerated_widget_mac/window_resize_helper_mac.cc

-// 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;
 class PumpableTaskRunner;
 typedef std::list<WrappedTask*> WrappedTaskQueue;
 typedef base::Callback<void(base::WaitableEvent*, base::TimeDelta)>
     EventTimedWaitCallback;
 
 // A wrapper for IPCs and tasks that we may potentially execute in
 // WaitForSingleTaskToRun. Because these tasks are sent to two places to run,
@@ skipping 22 matching lines @@
   DISALLOW_COPY_AND_ASSIGN(WrappedTask);
 };
 
 // The PumpableTaskRunner is a task runner that will wrap tasks in an
 // WrappedTask, enqueues that wrapped task in the queue to be pumped via
 // WaitForSingleWrappedTaskToRun during resizes, and posts the task to a
 // target task runner. The posted task will run only once, either through a
 // 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,
                                  WrappedTask* task,
                                  base::TimeDelta delay);
 
   // 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,
                        base::TimeDelta delay) override;
 
   bool PostNonNestableDelayedTask(const tracked_objects::Location& from_here,
                                   const base::Closure& task,
                                   base::TimeDelta delay) override;
 
   bool RunsTasksOnCurrentThread() const override;
@@ skipping 16 matching lines @@
   base::WaitableEvent event_;
 
   // Callback to call TimedWait on |event_| from an appropriate class.
   EventTimedWaitCallback event_timed_wait_callback_;
 
   scoped_refptr<base::SingleThreadTaskRunner> target_task_runner_;
 
   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;
 
 ////////////////////////////////////////////////////////////////////////////////
 // WrappedTask
 
 WrappedTask::WrappedTask(const base::Closure& closure, base::TimeDelta delay)
     : closure_(closure),
       can_run_time_(base::TimeTicks::Now() + delay),
       has_run_(false),
       sequence_number_(0) {}
@@ skipping 45 matching lines @@
     pumpable_task_runner_->task_queue_.erase(iterator_);
     iterator_ = pumpable_task_runner_->task_queue_.end();
   }
   pumpable_task_runner_ = NULL;
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // 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
   // be empty when it is destroyed.
   DCHECK(task_queue_.empty());
 }
 
 bool PumpableTaskRunner::WaitForSingleWrappedTaskToRun(
     const base::TimeDelta& max_delay) {
   base::TimeTicks stop_waiting_time = base::TimeTicks::Now() + max_delay;
@@ skipping 83 matching lines @@
   return false;
 }
 
 bool PumpableTaskRunner::RunsTasksOnCurrentThread() const {
   return target_task_runner_->RunsTasksOnCurrentThread();
 }
 
 }  // 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(
+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);
+}
+
+bool WindowResizeHelperMac::WaitForSingleTaskToRun(
     const base::TimeDelta& max_delay) {
   PumpableTaskRunner* pumpable_task_runner =
-      reinterpret_cast<PumpableTaskRunner*>(task_runner_.get());
+      static_cast<PumpableTaskRunner*>(task_runner_.get());
+  if (!pumpable_task_runner)
+    return false;
   return pumpable_task_runner->WaitForSingleWrappedTaskToRun(max_delay);
 }
 
-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());
-}
+WindowResizeHelperMac::WindowResizeHelperMac() {}
+WindowResizeHelperMac::~WindowResizeHelperMac() {}
 
-void RenderWidgetResizeHelper::PostGpuProcessMsg(int gpu_host_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(HandleGpuIPC, gpu_host_id, msg),
-                                 base::TimeDelta()),
-      base::TimeDelta());
-}
-
-RenderWidgetResizeHelper::RenderWidgetResizeHelper() {
-  task_runner_ = new PumpableTaskRunner(base::Bind(&EventTimedWait));
-}
-
-RenderWidgetResizeHelper::~RenderWidgetResizeHelper() {}
-
-// 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