Separate ResizeHelper from RenderWidgetHelper

content/browser/renderer_host/render_widget_resize_helper.h

+// Copyright 2014 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.
+
+#ifndef CONTENT_BROWSER_RENDERER_HOST_RENDER_WIDGET_RESIZE_HELPER_H_
+#define CONTENT_BROWSER_RENDERER_HOST_RENDER_WIDGET_RESIZE_HELPER_H_
+
+#include <deque>
+
+#include "base/lazy_instance.h"
+#include "base/synchronization/lock.h"
+#include "base/synchronization/waitable_event.h"
+#include "ipc/ipc_message.h"
+
+namespace content {
+
+// RenderWidgetResizeHelper is used to make resize appear smooth. That is to
+// say, make sure that the window size and the size of the content being drawn
+// in that window are resized in lock-step. This is accomplished by waiting
+// inside -[RenderWidgetHostViewCocoa setFrameSize:] for the renderer (and
+// potentially browser compositor as well) to produce a frame of same size
+// as the RenderWidgetHostViewCocoa.
+//
+// The function of waiting for a frame of the correct size is done inside
+// RenderWidgetHostImpl::WaitForSurface. That function will call
+// RenderWidgetResizeHelper::WaitForSingleTaskToRun until a timeout occurs,
+// or the corresponding RenderWidgetHostViewCocoa has a renderer frame of the
+// same size as its NSView.
+//
+// This is somewhat complicated because waiting for frames requires that
+// that the browser handle the IPCs (from the renderer and the GPU processes)
+// that are required to pick up a new frame. In the ordinary run of things
+// (ignoring RenderWidgetResizeHelper), those IPCs arrive on the IO thread
+// and are posted as tasks to the UI thread either by the RenderMessageFilter
+// (for renderer processes) or the GpuProcessHostUIShim (for the GPU process).
+// The IPCs that are required to create new frames for smooth resize are sent
+// to the RenderWidgetResizeHelper using the PostRendererProcessMsg and
+// PostGpuProcessMsg methods. These functions will post them as tasks to the UI
+// thread (as usual), and will also enqueue them into a queue which will be
+// read and run in RenderWidgetResizeHelper::WaitForSingleTaskToRun, potentially
+// before the task posted to the UI thread is run. Some care is taken (see
+// EnqueuedTask) to make sure that the messages are only executed once.
+//
+// TODO(ccameron): This does not support smooth resize when using the
+// ui::Compositor yet. To support this, it will be necessary that the
+// RenderWidgetResizeHelper have a base::TaskRunner to send to the
+// cc::ThreadProxy. The tasks that cc then posts can be pumped in
+// WaitForSingleTaskToRun in a way similar to the one in which IPCs are handled.
+//
+class RenderWidgetResizeHelper {
+ public:
+  static RenderWidgetResizeHelper* Get();
+
+  // UI THREAD ONLY -----------------------------------------------------------
+
+  // Waits at most |max_delay| for a task to run. Returns true if a task ran,
+  // false if no task ran.
+  bool WaitForSingleTaskToRun(const base::TimeDelta& max_delay);
+
+  // IO THREAD ONLY -----------------------------------------------------------
+
+  // This will cause |msg| to be handled by the RenderProcessHost corresponding
+  // to |render_process_id|, on the UI thread. This will either happen when the
+  // ordinary message loop would run it, or potentially earlier in a call to
+  // WaitForSingleTaskToRun .
+  void PostRendererProcessMsg(int render_process_id, const IPC::Message& msg);
+
+  // This is similar to PostRendererProcessMsg, but will handle the message in
+  // the GpuProcessHostUIShim corresponding to |gpu_host_id|.
+  void PostGpuProcessMsg(int gpu_host_id, const IPC::Message& msg);
+
+ private:
+  friend struct base::DefaultLazyInstanceTraits<RenderWidgetResizeHelper>;
+  RenderWidgetResizeHelper();
+  ~RenderWidgetResizeHelper();
+
+  // A classed used to wrap an IPC or a task.
+  class EnqueuedTask;
+  friend class EnqueuedTask;
+
+  // Called on the IO thread to add a task to the queue.
+  void PostEnqueuedTask(EnqueuedTask* proxy);
+
+  // Called on the UI to remove the task from the queue when it is run.
+  void WillRunEnqueuedTask(EnqueuedTask* proxy);
+
+  // A queue of live messages.  Must hold |task_queue_lock_| to access.
+  // The EnqueuedTask objects are removed from the front of the queue when
+  // they are run (either by TaskRunner they were posted to or by a call to
+  // WaitForSingleTaskToRun pulling them off of the queue).
+  typedef std::deque<EnqueuedTask*> EnqueuedTaskQueue;
+  EnqueuedTaskQueue task_queue_;
+  base::Lock task_queue_lock_;
+
+  // Event used to wake up the UI thread if it is sleeping in
+  // WaitForSingleTaskToRun.
+  base::WaitableEvent event_;
+};
+
+}  // namespace content
+
+#endif  // CONTENT_BROWSER_RENDERER_HOST_RENDER_WIDGET_RESIZE_HELPER_H_