aura: Remove old GL paths from RenderWidgetHostViewAura.

content/renderer/gpu/compositor_output_surface.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/renderer/gpu/compositor_output_surface.h"
 
 #include "base/command_line.h"
 #include "base/message_loop/message_loop_proxy.h"
 #include "cc/output/compositor_frame.h"
 #include "cc/output/compositor_frame_ack.h"
@@ skipping 43 matching lines @@
     const scoped_refptr<ContextProviderCommandBuffer>& context_provider,
     scoped_ptr<cc::SoftwareOutputDevice> software_device,
     bool use_swap_compositor_frame_message)
     : OutputSurface(context_provider, software_device.Pass()),
       output_surface_id_(output_surface_id),
       use_swap_compositor_frame_message_(use_swap_compositor_frame_message),
       output_surface_filter_(
           RenderThreadImpl::current()->compositor_output_surface_filter()),
       routing_id_(routing_id),
       prefers_smoothness_(false),
+      layout_test_mode_(RenderThreadImpl::current()->layout_test_mode()),
 #if defined(OS_WIN)
       // TODO(epenner): Implement PlatformThread::CurrentHandle() on windows.
       main_thread_handle_(base::PlatformThreadHandle())
 #else
       main_thread_handle_(base::PlatformThread::CurrentHandle())
 #endif
 {
   DCHECK(output_surface_filter_.get());
   DetachFromThread();
   message_sender_ = RenderThreadImpl::current()->sync_message_filter();
@@ skipping 30 matching lines @@
     // Without a GPU context, the memory policy otherwise wouldn't be set.
     client->SetMemoryPolicy(cc::ManagedMemoryPolicy(
         64 * 1024 * 1024,
         gpu::MemoryAllocation::CUTOFF_ALLOW_NICE_TO_HAVE,
         cc::ManagedMemoryPolicy::kDefaultNumResourcesLimit));
   }
 
   return true;
 }
 
+void CompositorOutputSurface::ShortcutSwapAck(
+    int output_surface_id,
+    scoped_ptr<cc::CompositorFrameAck> ack) {
+  ReclaimResources(ack.get());
+  OnSwapBuffersComplete();
+}
+
 void CompositorOutputSurface::SwapBuffers(cc::CompositorFrame* frame) {
+  if (layout_test_mode_) {
+    // This code path is here to support layout tests that are currently
+    // doing a readback in the renderer instead of the browser. So they
+    // are using deprecated code paths in the renderer and don't need to
+    // actually swap anything to the browser. We shortcut the swap to the
+    // browser here and just ack directly within the renderer process.
+    // Once crbug.com/311404 is fixed, this can be removed.
+    DCHECK(use_swap_compositor_frame_message_);
+    DidSwapBuffers();
+
+    // This would indicate that crbug.com/311404 is being fixed, and this
+    // block needs to be removed.
+    DCHECK(!frame->delegated_frame_data);
+
+    scoped_ptr<cc::CompositorFrameAck> ack(new cc::CompositorFrameAck);
+    if (frame->gl_frame_data)
+      ack->gl_frame_data = frame->gl_frame_data.Pass();
+    if (frame->software_frame_data)
+      ack->last_software_frame_id = frame->software_frame_data->id;
+    base::MessageLoopProxy::current()->PostTask(
+        FROM_HERE,
+        base::Bind(&CompositorOutputSurface::ShortcutSwapAck,
+                   base::Unretained(this),

[piman, 2014/02/07 21:51:24]

Is this Unretained safe?

[danakj, 2014/02/07 21:58:44]

I *think* so, cuz I'm not seeing crashes on layout tests.. do you think I should
WeakPtr? I wasn't really sure.

[piman, 2014/02/07 23:07:17]

I don't see anything that would guarantee it.
On shutdown, I don't see code that waits for all the swap acks before destroying
the LTHI which is what would destroy the OS (besides, in non-threaded mode, we
can't).

I think a WeakPtrFactory would be safer.

[danakj, 2014/02/08 00:55:32]

ok! done.

+                   output_surface_id_,

[piman, 2014/02/07 21:51:24]

nit: You're not using this AFAICT

[danakj, 2014/02/07 21:58:44]

Oh, ya. I was passing this to the OnSwapAck() but not doing that now.

+                   base::Passed(&ack)));
+    return;
+  }
+
   if (use_swap_compositor_frame_message_) {
     Send(new ViewHostMsg_SwapCompositorFrame(routing_id_,
                                              output_surface_id_,
                                              *frame));
     DidSwapBuffers();
     return;
   }
 
   if (frame->gl_frame_data) {
     context_provider_->ContextGL()->ShallowFlushCHROMIUM();
@@ skipping 101 matching lines @@
   // If this is the last surface to stop preferring smoothness,
   // Reset the main thread's priority to the default.
   if (prefers_smoothness_ == true &&
       --g_prefer_smoothness_count == 0) {
     SetThreadPriorityToDefault(main_thread_handle_);
   }
   prefers_smoothness_ = prefers_smoothness;
 }
 
 }  // namespace content