sync compositor: Move DeliverMessages to OutputSurface

content/renderer/android/synchronous_compositor_proxy.cc

 // Copyright 2015 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_proxy.h"
 
 #include "base/auto_reset.h"
 #include "base/command_line.h"
 #include "base/memory/shared_memory.h"
 #include "content/common/android/sync_compositor_messages.h"
@@ skipping 48 matching lines @@
   SetOutputSurface(nullptr);
   begin_frame_source_->SetClient(nullptr);
   input_handler_proxy_->SetOnlySynchronouslyAnimateRootFlings(nullptr);
 }
 
 void SynchronousCompositorProxy::SetOutputSurface(
     SynchronousCompositorOutputSurface* output_surface) {
   DCHECK_NE(output_surface_, output_surface);
   if (output_surface_) {
     output_surface_->SetSyncClient(nullptr);
-    output_surface_->SetTreeActivationCallback(base::Closure());
   }
   output_surface_ = output_surface;
   if (output_surface_) {
     output_surface_->SetSyncClient(this);
-    output_surface_->SetTreeActivationCallback(
-        base::Bind(&SynchronousCompositorProxy::DidActivatePendingTree,
-                   base::Unretained(this)));
   }
 }
 
 void SynchronousCompositorProxy::SetNeedsSynchronousAnimateInput() {
   need_animate_scroll_ = true;
   Invalidate();
 }
 
 void SynchronousCompositorProxy::UpdateRootLayerState(
     const gfx::ScrollOffset& total_scroll_offset,
@@ skipping 28 matching lines @@
 }
 
 void SynchronousCompositorProxy::Invalidate() {
   ++need_invalidate_count_;
   SendAsyncRendererStateIfNeeded();
 }
 
 void SynchronousCompositorProxy::DidActivatePendingTree() {
   ++did_activate_pending_tree_count_;
   SendAsyncRendererStateIfNeeded();
-  DeliverMessages();
-}
-
-void SynchronousCompositorProxy::DeliverMessages() {
-  DCHECK(output_surface_);
-  std::vector<std::unique_ptr<IPC::Message>> messages;
-  output_surface_->GetMessagesToDeliver(&messages);
-  for (auto& msg : messages) {
-    Send(msg.release());
-  }
 }
 
 void SynchronousCompositorProxy::SendAsyncRendererStateIfNeeded() {
   if (inside_receive_)
     return;
   SyncCompositorCommonRendererParams params;
   PopulateCommonParams(&params);
   Send(new SyncCompositorHostMsg_UpdateState(routing_id_, params));
 }
 
@@ skipping 83 matching lines @@
                                   params.viewport, params.clip,
                                   params.viewport_rect_for_tile_priority,
                                   params.transform_for_tile_priority);
   }
 
   if (inside_receive_) {
     // Did not swap.
     cc::CompositorFrame empty_frame;
     SendDemandDrawHwReply(&empty_frame, 0u, reply_message);
     inside_receive_ = false;
-  } else {
-    DeliverMessages();
   }
 }
 
 void SynchronousCompositorProxy::SwapBuffersHw(uint32_t output_surface_id,
                                                cc::CompositorFrame* frame) {
   DCHECK(inside_receive_);
   DCHECK(hardware_draw_reply_);
   DCHECK(frame);
   SendDemandDrawHwReply(frame, output_surface_id, hardware_draw_reply_);
   inside_receive_ = false;
@@ skipping 64 matching lines @@
     } else {
       DCHECK(!sk_canvas_for_draw);
       DoDemandDrawSw(params);
     }
   }
   if (inside_receive_) {
     // Did not swap.
     cc::CompositorFrame empty_frame;
     SendDemandDrawSwReply(false, &empty_frame, reply_message);
     inside_receive_ = false;
-  } else {
-    DeliverMessages();
   }
 }
 
 void SynchronousCompositorProxy::DoDemandDrawSw(
     const SyncCompositorDemandDrawSwParams& params) {
   DCHECK(output_surface_);
   DCHECK(software_draw_shm_->zeroed);
   software_draw_shm_->zeroed = false;
 
   SkImageInfo info =
@@ skipping 80 matching lines @@
                                             did_overscroll_params));
 }
 
 void SynchronousCompositorProxy::ProcessCommonParams(
     const SyncCompositorCommonBrowserParams& common_params) {
   begin_frame_source_->SetBeginFrameSourcePaused(
       common_params.begin_frame_source_paused);
 }
 
 }  // namespace content