sync compositor: Send ipc reply in swap

content/browser/android/in_process/synchronous_compositor_impl.cc

 // Copyright 2013 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/android/in_process/synchronous_compositor_impl.h"
 
+#include <utility>
+
 #include "base/auto_reset.h"
 #include "base/bind.h"
 #include "base/lazy_instance.h"
 #include "base/message_loop/message_loop.h"
 #include "content/browser/android/in_process/synchronous_compositor_factory_impl.h"
 #include "content/browser/android/in_process/synchronous_compositor_registry_in_proc.h"
 #include "content/browser/android/in_process/synchronous_input_event_filter.h"
 #include "content/browser/gpu/gpu_process_host.h"
 #include "content/browser/renderer_host/render_widget_host_view_android.h"
 #include "content/common/input/did_overscroll_params.h"
@@ skipping 139 matching lines @@
 scoped_ptr<cc::CompositorFrame> SynchronousCompositorImpl::DemandDrawHw(
     const gfx::Size& surface_size,
     const gfx::Transform& transform,
     const gfx::Rect& viewport,
     const gfx::Rect& clip,
     const gfx::Rect& viewport_rect_for_tile_priority,
     const gfx::Transform& transform_for_tile_priority) {
   DCHECK(CalledOnValidThread());
   DCHECK(output_surface_);
   DCHECK(begin_frame_source_);
+  DCHECK(!frame_holder_);
 
-  scoped_ptr<cc::CompositorFrame> frame =
-      output_surface_->DemandDrawHw(surface_size,
-                                    transform,
-                                    viewport,
-                                    clip,
-                                    viewport_rect_for_tile_priority,
-                                    transform_for_tile_priority);
+  output_surface_->DemandDrawHw(surface_size, transform, viewport, clip,
+                                viewport_rect_for_tile_priority,
+                                transform_for_tile_priority);
 
-  if (frame.get())
-    UpdateFrameMetaData(frame->metadata);
+  if (frame_holder_)

[hush (inactive), 2015/12/29 19:42:17]

just checking, because the DemandDrawHw is synchronous here, doing so with the
in process compositor has no performance benefit right? This is done for the
sake of consistency with CompositorProxy implementation.

[boliu, 2015/12/29 20:22:52]

Yep. SynchronousCompositorOutputSurface implementation is shared between
in-process and ipc paths.

+    UpdateFrameMetaData(frame_holder_->metadata);
 
-  return frame.Pass();
+  return std::move(frame_holder_);

[hush (inactive), 2015/12/29 19:42:17]

How is this is different from frame_holder_.pass()? No difference?

[boliu, 2015/12/29 20:22:52]

No difference afaik. Presumit check says std::move is the way to go now.

Note that for scoped_ptr (and std::unique_ptr), the moved-from value after move
is defined to be null (just like Pass), so no need to null it out afterwards.
This is not true for types in general; apparently specs says the moved-from
value becomes undefined, and only safe operations on it after move are
assignment and destruction.

 }
 
 void SynchronousCompositorImpl::ReturnResources(
     const cc::CompositorFrameAck& frame_ack) {
   DCHECK(CalledOnValidThread());
   output_surface_->ReturnResources(frame_ack);
 }
 
 bool SynchronousCompositorImpl::DemandDrawSw(SkCanvas* canvas) {
   DCHECK(CalledOnValidThread());
   DCHECK(output_surface_);
   DCHECK(begin_frame_source_);
+  DCHECK(!frame_holder_);
 
-  scoped_ptr<cc::CompositorFrame> frame =
-      output_surface_->DemandDrawSw(canvas);
+  output_surface_->DemandDrawSw(canvas);
 
-  if (frame.get())
-    UpdateFrameMetaData(frame->metadata);
+  bool success = !!frame_holder_;
+  if (frame_holder_) {
+    UpdateFrameMetaData(frame_holder_->metadata);
+    frame_holder_.reset();
+  }
 
-  return !!frame.get();
+  return success;
+}
+
+void SynchronousCompositorImpl::SwapBuffers(cc::CompositorFrame* frame) {
+  DCHECK(!frame_holder_);
+  frame_holder_.reset(new cc::CompositorFrame);
+  frame->AssignTo(frame_holder_.get());
 }
 
 void SynchronousCompositorImpl::UpdateFrameMetaData(
     const cc::CompositorFrameMetadata& frame_metadata) {
   rwhva_->SynchronousFrameMetadata(frame_metadata);
   DeliverMessages();
 }
 
 void SynchronousCompositorImpl::SetMemoryPolicy(size_t bytes_limit) {
   DCHECK(CalledOnValidThread());
@@ skipping 140 matching lines @@
   }
 }
 
 // Not using base::NonThreadSafe as we want to enforce a more exacting threading
 // requirement: SynchronousCompositorImpl() must only be used on the UI thread.
 bool SynchronousCompositorImpl::CalledOnValidThread() const {
   return BrowserThread::CurrentlyOn(BrowserThread::UI);
 }
 
 }  // namespace content