Mac ÜC: Make resize smooth

content/browser/gpu/gpu_process_host.cc

 // Copyright (c) 2012 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/gpu/gpu_process_host.h"
 
 #include "base/base64.h"
 #include "base/base_switches.h"
 #include "base/basictypes.h"
 #include "base/bind.h"
@@ skipping 834 matching lines @@
 void GpuProcessHost::OnAcceleratedSurfaceBuffersSwapped(
     const GpuHostMsg_AcceleratedSurfaceBuffersSwapped_Params& params) {
   TRACE_EVENT0("gpu", "GpuProcessHost::OnAcceleratedSurfaceBuffersSwapped");
 
   if (!ui::LatencyInfo::Verify(params.latency_info,
                                "GpuHostMsg_AcceleratedSurfaceBuffersSwapped"))
     return;
 
   gfx::AcceleratedWidget native_widget =
       GpuSurfaceTracker::Get()->AcquireNativeWidget(params.surface_id);
+
+  // Retrieve the render widget helper to forward this message to on the UI
+  // thread.
+  RenderWidgetHelper* helper = NULL;
+  int render_widget_id = 0;
   if (native_widget) {
-    RenderWidgetHelper::OnNativeSurfaceBuffersSwappedOnIOThread(this, params);
-    return;
+    int render_process_id = 0;
+    if (RenderWidgetHelper::GetRenderWidgetIDForWidget(
+            native_widget, &render_process_id, &render_widget_id)) {

[piman, 2014/07/07 18:27:43]

Why do we need this? What's different with the
render_process_id/render_widget_id given by
GpuSurfaceTracker::Get()->GetRenderWidgetIDForSurface?

[ccameron, 2014/07/07 18:45:23]

The surface was created for the browser, so it doesn't have a render widget
associated with it (and arguably shouldn't, at least at the GpuSurfaceTracker
level -- those properties are static for the lifetime of a surface, but the RWH
for a browser compositor can change over time).

[piman, 2014/07/07 19:40:56]

I'm worried about races (lookup is done on the IO thread but association is done
on the main thread). Can you detail to me how it fits together? In particular,
as you reuse a browser compositor when switching tabs, what ensures the RWHelper
you look up here will always be correct? A case to consider is: a frame from the
previous tab is queued, then the tab is switched, and the native_widget <->
render_process_id association changes, and then the GPU process draws the frame
and sends the GpuHostMsg_AcceleratedSurfaceBuffersSwapped. What ensures this
won't go to the new RWHelper instead of the old one?
Vice-versa, can there be a case where the
GpuHostMsg_AcceleratedSurfaceBuffersSwapped for the new tab comes "too early"
and goes to the old RWHelper rather than the new one?

+      helper = RenderWidgetHelper::FromProcessHostID(render_process_id);
+    }
+  } else {
+    int render_process_id = 0;
+    if (GpuSurfaceTracker::Get()->GetRenderWidgetIDForSurface(
+        params.surface_id, &render_process_id, &render_widget_id)) {
+      helper = RenderWidgetHelper::FromProcessHostID(render_process_id);
+    }
   }
 
-  gfx::GLSurfaceHandle surface_handle =
-      GpuSurfaceTracker::Get()->GetSurfaceHandle(params.surface_id);
-  // Compositor window is always gfx::kNullPluginWindow.
-  // TODO(jbates) http://crbug.com/105344 This will be removed when there are no
-  // plugin windows.
-  if (surface_handle.handle != gfx::kNullPluginWindow ||
-      surface_handle.transport_type == gfx::TEXTURE_TRANSPORT) {
-    RouteOnUIThread(GpuHostMsg_AcceleratedSurfaceBuffersSwapped(params));
-    return;
-  }
-
-  AcceleratedSurfaceMsg_BufferPresented_Params ack_params;
-  ack_params.sync_point = 0;
-
-  int render_process_id = 0;
-  int render_widget_id = 0;
-  if (!GpuSurfaceTracker::Get()->GetRenderWidgetIDForSurface(
-      params.surface_id, &render_process_id, &render_widget_id)) {
-    Send(new AcceleratedSurfaceMsg_BufferPresented(params.route_id,
-                                                   ack_params));
-    return;
-  }
-  RenderWidgetHelper* helper =
-      RenderWidgetHelper::FromProcessHostID(render_process_id);
-  if (!helper) {
+  // If this is not targetting a native widget and we don't find a helper, then
+  // ack immediately and ignore the message.
+  if (!helper && !native_widget) {
+    AcceleratedSurfaceMsg_BufferPresented_Params ack_params;
+    ack_params.sync_point = 0;
     Send(new AcceleratedSurfaceMsg_BufferPresented(params.route_id,
                                                    ack_params));
     return;
   }
 
+  // If this is targetting a native widget, then ack the swap immediately to
+  // avoid introducing a deadlock between the browser and GPU processes (rate
+  // limiting is done through the compositor).
+  if (native_widget) {
+    AcceleratedSurfaceMsg_BufferPresented_Params ack_params;
+    ack_params.sync_point = 0;
+    Send(new AcceleratedSurfaceMsg_BufferPresented(params.route_id,
+                                                   ack_params));
+  }
+
   // Pass the SwapBuffers on to the RenderWidgetHelper to wake up the UI thread
   // if the browser is waiting for a new frame. Otherwise the RenderWidgetHelper
   // will forward to the RenderWidgetHostView via RenderProcessHostImpl and
   // RenderWidgetHostImpl.
   ViewHostMsg_CompositorSurfaceBuffersSwapped_Params view_params;
+  view_params.use_native_widget = native_widget;
   view_params.surface_id = params.surface_id;
   view_params.surface_handle = params.surface_handle;
   view_params.route_id = params.route_id;
   view_params.size = params.size;
   view_params.scale_factor = params.scale_factor;
   view_params.gpu_process_host_id = host_id_;
   view_params.latency_info = params.latency_info;
-  helper->DidReceiveBackingStoreMsg(ViewHostMsg_CompositorSurfaceBuffersSwapped(
-      render_widget_id,
-      view_params));
+  if (helper) {
+    helper->DidReceiveBackingStoreMsg(
+        ViewHostMsg_CompositorSurfaceBuffersSwapped(
+            render_widget_id,
+            view_params));
+  } else if (native_widget) {
+    BrowserThread::PostTask(
+        BrowserThread::UI,
+        FROM_HERE,
+        base::Bind(&RenderWidgetHelper::OnNativeSurfaceBuffersSwappedOnUIThread,
+                       view_params));
+  }
 }
 #endif  // OS_MACOSX
 
 void GpuProcessHost::OnProcessLaunched() {
   UMA_HISTOGRAM_TIMES("GPU.GPUProcessLaunchTime",
                       base::TimeTicks::Now() - init_start_time_);
 }
 
 void GpuProcessHost::OnProcessCrashed(int exit_code) {
   SendOutstandingReplies();
@@ skipping 204 matching lines @@
   TRACE_EVENT0("gpu", "GpuProcessHost::OnCacheShader");
   ClientIdToShaderCacheMap::iterator iter =
       client_id_to_shader_cache_.find(client_id);
   // If the cache doesn't exist then this is an off the record profile.
   if (iter == client_id_to_shader_cache_.end())
     return;
   iter->second->Cache(GetShaderPrefixKey() + ":" + key, shader);
 }
 
 }  // namespace content