sync compositor: Move DeliverMessages to OutputSurface

content/renderer/android/synchronous_compositor_output_surface.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/renderer/android/synchronous_compositor_output_surface.h"
 
+#include <vector>
+
 #include "base/auto_reset.h"
 #include "base/logging.h"
 #include "base/macros.h"
 #include "cc/output/compositor_frame.h"
 #include "cc/output/context_provider.h"
 #include "cc/output/output_surface_client.h"
 #include "cc/output/software_output_device.h"
 #include "content/common/android/sync_compositor_messages.h"
 #include "content/renderer/android/synchronous_compositor_external_begin_frame_source.h"
 #include "content/renderer/android/synchronous_compositor_filter.h"
@@ skipping 101 matching lines @@
   return handled;
 }
 
 bool SynchronousCompositorOutputSurface::BindToClient(
     cc::OutputSurfaceClient* surface_client) {
   DCHECK(CalledOnValidThread());
   if (!cc::OutputSurface::BindToClient(surface_client))
     return false;
 
   client_->SetMemoryPolicy(memory_policy_);
+  client_->SetTreeActivationCallback(
+      base::Bind(&SynchronousCompositorOutputSurface::DidActivatePendingTree,
+                 base::Unretained(this)));
   registry_->RegisterOutputSurface(routing_id_, this);
   registered_ = true;
   Send(new SyncCompositorHostMsg_OutputSurfaceCreated(routing_id_));
   return true;
 }
 
 void SynchronousCompositorOutputSurface::DetachFromClient() {
   DCHECK(CalledOnValidThread());
   if (registered_) {
     registry_->UnregisterOutputSurface(routing_id_, this);
   }
+  client_->SetTreeActivationCallback(base::Closure());

[boliu, 2016/05/13 22:40:20]

added this line

   cc::OutputSurface::DetachFromClient();
   CancelFallbackTick();
 }
 
 void SynchronousCompositorOutputSurface::Reshape(const gfx::Size& size,
                                                  float scale_factor,
                                                  bool has_alpha) {
   // Intentional no-op: surface size is controlled by the embedder.
 }
 
 void SynchronousCompositorOutputSurface::SwapBuffers(
     cc::CompositorFrame* frame) {
   DCHECK(CalledOnValidThread());
   DCHECK(sync_client_);
-  if (!fallback_tick_running_)
+  if (!fallback_tick_running_) {
     sync_client_->SwapBuffers(output_surface_id_, frame);
+    DeliverMessages();
+  }
   client_->DidSwapBuffers();
   did_swap_ = true;
 }
 
 void SynchronousCompositorOutputSurface::CancelFallbackTick() {
   fallback_tick_.Cancel();
   fallback_tick_pending_ = false;
 }
 
 void SynchronousCompositorOutputSurface::FallbackTickFired() {
@@ skipping 104 matching lines @@
     // This is small hack to drop context resources without destroying it
     // when this compositor is put into the background.
     context_provider()->ContextSupport()->SetAggressivelyFreeResources(
         true /* aggressively_free_resources */);
   } else if (became_non_zero) {
     context_provider()->ContextSupport()->SetAggressivelyFreeResources(
         false /* aggressively_free_resources */);
   }
 }
 
-void SynchronousCompositorOutputSurface::SetTreeActivationCallback(
-    const base::Closure& callback) {
-  DCHECK(client_);
-  client_->SetTreeActivationCallback(callback);
+void SynchronousCompositorOutputSurface::DidActivatePendingTree() {
+  DCHECK(CalledOnValidThread());
+  if (sync_client_)
+    sync_client_->DidActivatePendingTree();
+  DeliverMessages();
 }
 
-void SynchronousCompositorOutputSurface::GetMessagesToDeliver(
-    std::vector<std::unique_ptr<IPC::Message>>* messages) {
-  DCHECK(CalledOnValidThread());
+void SynchronousCompositorOutputSurface::DeliverMessages() {
+  std::vector<std::unique_ptr<IPC::Message>> messages;
   std::unique_ptr<FrameSwapMessageQueue::SendMessageScope> send_message_scope =
       frame_swap_message_queue_->AcquireSendMessageScope();
-  frame_swap_message_queue_->DrainMessages(messages);
+  frame_swap_message_queue_->DrainMessages(&messages);
+  for (auto& msg : messages) {
+    Send(msg.release());
+  }
 }
 
 bool SynchronousCompositorOutputSurface::Send(IPC::Message* message) {
   DCHECK(CalledOnValidThread());
   return sender_->Send(message);
 }
 
 bool SynchronousCompositorOutputSurface::CalledOnValidThread() const {
   return thread_checker_.CalledOnValidThread();
 }
 
 }  // namespace content