MacViews: Synchronize resize operations with the GPU process

ui/views/cocoa/bridged_native_widget.mm

 // 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.
 
 #import "ui/views/cocoa/bridged_native_widget.h"
 
 #import <objc/runtime.h>
 
 #include "base/logging.h"
 #import "base/mac/foundation_util.h"
 #include "base/mac/mac_util.h"
 #import "base/mac/sdk_forward_declarations.h"
 #include "base/thread_task_runner_handle.h"
+#include "ui/accelerated_widget_mac/window_resize_helper_mac.h"
 #import "ui/base/cocoa/constrained_window/constrained_window_animation.h"
 #include "ui/base/hit_test.h"
 #include "ui/base/ime/input_method.h"
 #include "ui/base/ime/input_method_factory.h"
 #include "ui/gfx/display.h"
 #include "ui/gfx/geometry/dip_util.h"
 #import "ui/gfx/mac/coordinate_conversion.h"
 #import "ui/gfx/mac/nswindow_frame_controls.h"
 #include "ui/gfx/screen.h"
 #import "ui/views/cocoa/bridged_content_view.h"
@@ skipping 182 matching lines @@
   if (monitor)
     return;
 
   monitor = [NSEvent
       addLocalMonitorForEventsMatchingMask:NSLeftMouseDownMask
       handler:^NSEvent*(NSEvent* ns_event) {
         return RepostEventIfHandledByWindow(ns_event);
       }];
 }
 
+// Returns a task runner for creating a ui::Compositor. This allows compositor
+// tasks to be funneled through ui::WindowResizeHelper's task runner to allow
+// resize operations to coordinate with frames provided by the GPU process.
+scoped_refptr<base::SingleThreadTaskRunner> GetCompositorTaskRunner() {
+  // If the WindowResizeHelper's pumpable task runner is set, it means the GPU
+  // process is directing messages there, and the compositor can synchronize
+  // with it. Otherwise, just use the UI thread.
+  scoped_refptr<base::SingleThreadTaskRunner> task_runner =
+      ui::WindowResizeHelperMac::Get()->task_runner();
+  return task_runner ? task_runner : base::ThreadTaskRunnerHandle::Get();
+}
+
 }  // namespace
 
 namespace views {
 
 // static
 gfx::Size BridgedNativeWidget::GetWindowSizeForClientSize(
     NSWindow* window,
     const gfx::Size& content_size) {
   NSRect content_rect =
       NSMakeRect(0, 0, content_size.width(), content_size.height());
@@ skipping 386 matching lines @@
   // 2: the fullscreen button must be enabled so the user can leave fullscreen.
   // This will be reset when a transition out of fullscreen completes.
   gfx::SetNSWindowCanFullscreen(window_, true);
 
   [window_ toggleFullScreen:nil];
 }
 
 void BridgedNativeWidget::OnSizeChanged() {
   gfx::Size new_size = GetClientAreaSize();
   native_widget_mac_->GetWidget()->OnNativeWidgetSizeChanged(new_size);
-  if (layer())
+  if (layer()) {
     UpdateLayerProperties();
+    if ([window_ inLiveResize])
+      MaybeWaitForFrame(new_size);
+  }
 }
 
 void BridgedNativeWidget::OnVisibilityChanged() {
   OnVisibilityChangedTo([window_ isVisible]);
 }
 
 void BridgedNativeWidget::OnVisibilityChangedTo(bool new_visibility) {
   if (window_visible_ == new_visibility)
     return;
 
@@ skipping 371 matching lines @@
   DCHECK(context_factory);
 
   AddCompositorSuperview();
 
   // TODO(tapted): Get this value from GpuDataManagerImpl via ViewsDelegate.
   bool needs_gl_finish_workaround = false;
 
   compositor_widget_.reset(
       new ui::AcceleratedWidgetMac(needs_gl_finish_workaround));
   compositor_.reset(
-      new ui::Compositor(context_factory, base::ThreadTaskRunnerHandle::Get()));
+      new ui::Compositor(context_factory, GetCompositorTaskRunner()));
   compositor_->SetAcceleratedWidgetAndStartCompositor(
       compositor_widget_->accelerated_widget());
   compositor_widget_->SetNSView(this);
 }
 
 void BridgedNativeWidget::InitCompositor() {
   DCHECK(layer());
   float scale_factor = GetDeviceScaleFactorFromView(compositor_superview_);
   gfx::Size size_in_dip = GetClientAreaSize();
   compositor_->SetScaleAndSize(scale_factor,
@@ skipping 76 matching lines @@
   float scale_factor = GetDeviceScaleFactorFromView(compositor_superview_);
   compositor_->SetScaleAndSize(scale_factor,
                                ConvertSizeToPixel(scale_factor, size_in_dip));
 
   // For a translucent window, the shadow calculation needs to be carried out
   // after the frame from the compositor arrives.
   if (![window_ isOpaque])
     invalidate_shadow_on_frame_swap_ = true;
 }
 
+void BridgedNativeWidget::MaybeWaitForFrame(const gfx::Size& size_in_dip) {
+  if (!layer()->IsDrawn() || compositor_widget_->HasFrameOfSize(size_in_dip))
+    return;
+
+  const int kPaintMsgTimeoutMS = 50;
+  const base::TimeTicks start_time = base::TimeTicks::Now();
+  const base::TimeTicks timeout_time =
+      start_time + base::TimeDelta::FromMilliseconds(kPaintMsgTimeoutMS);
+
+  ui::WindowResizeHelperMac* resize_helper = ui::WindowResizeHelperMac::Get();
+  for (base::TimeTicks now = start_time; now < timeout_time;
+       now = base::TimeTicks::Now()) {
+    if (!resize_helper->WaitForSingleTaskToRun(timeout_time - now))
+      return;  // Timeout.
+
+    // Since the UI thread is blocked, the size shouldn't change.
+    DCHECK(size_in_dip == GetClientAreaSize());
+    if (compositor_widget_->HasFrameOfSize(size_in_dip))
+      return;  // Frame arrived.
+  }
+}
+
 NSMutableDictionary* BridgedNativeWidget::GetWindowProperties() const {
   NSMutableDictionary* properties = objc_getAssociatedObject(
       window_, &kWindowPropertiesKey);
   if (!properties) {
     properties = [NSMutableDictionary dictionary];
     objc_setAssociatedObject(window_, &kWindowPropertiesKey,
                              properties, OBJC_ASSOCIATION_RETAIN);
   }
   return properties;
 }
 
 void BridgedNativeWidget::SetDraggable(bool draggable) {
   [bridged_view_ setMouseDownCanMoveWindow:draggable];
   // AppKit will not update its cache of mouseDownCanMoveWindow unless something
   // changes. Previously we tried adding an NSView and removing it, but for some
   // reason it required reposting the mouse-down event, and didn't always work.
   // Calling the below seems to be an effective solution.
   [window_ setMovableByWindowBackground:NO];
   [window_ setMovableByWindowBackground:YES];
 }
 
 }  // namespace views