Deliver IPC messages together with SwapCompositorFrame

content/browser/android/in_process/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/browser/android/in_process/synchronous_compositor_output_surface.h"
 
 #include "base/auto_reset.h"
 #include "base/logging.h"
 #include "cc/output/begin_frame_args.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/browser/android/in_process/synchronous_compositor_impl.h"
 #include "content/public/browser/browser_thread.h"
+#include "content/renderer/gpu/frame_swap_message_queue.h"
 #include "gpu/command_buffer/client/gles2_interface.h"
 #include "gpu/command_buffer/common/gpu_memory_allocation.h"
 #include "third_party/skia/include/core/SkCanvas.h"
 #include "ui/gfx/rect_conversions.h"
 #include "ui/gfx/skia_util.h"
 #include "ui/gfx/transform.h"
 
 namespace content {
 
 namespace {
@@ skipping 33 matching lines @@
   }
 
  private:
   SynchronousCompositorOutputSurface* surface_;
   SkCanvas null_canvas_;
 
   DISALLOW_COPY_AND_ASSIGN(SoftwareDevice);
 };
 
 SynchronousCompositorOutputSurface::SynchronousCompositorOutputSurface(
-    int routing_id)
+    int routing_id,
+    scoped_refptr<FrameSwapMessageQueue> frame_swap_message_queue)
     : cc::OutputSurface(
           scoped_ptr<cc::SoftwareOutputDevice>(new SoftwareDevice(this))),
       routing_id_(routing_id),
       needs_begin_frame_(false),
       invoking_composite_(false),
       did_swap_buffer_(false),
       current_sw_canvas_(NULL),
       memory_policy_(0),
       output_surface_client_(NULL),
+      frame_swap_message_queue_(frame_swap_message_queue),
       weak_ptr_factory_(this) {
   capabilities_.deferred_gl_initialization = true;
   capabilities_.draw_and_swap_full_viewport_every_frame = true;
   capabilities_.adjust_deadline_for_parent = false;
   // Cannot call out to GetDelegate() here as the output surface is not
   // constructed on the correct thread.
 
   memory_policy_.priority_cutoff_when_visible =
       gpu::MemoryAllocation::CUTOFF_ALLOW_NICE_TO_HAVE;
 }
@@ skipping 48 matching lines @@
     cc::CompositorFrame* frame) {
   DCHECK(CalledOnValidThread());
   if (!ForcedDrawToSoftwareDevice()) {
     DCHECK(context_provider_);
     context_provider_->ContextGL()->ShallowFlushCHROMIUM();
   }
   UpdateFrameMetaData(frame->metadata);
 
   did_swap_buffer_ = true;
   client_->DidSwapBuffers();
+
+  std::vector<IPC::Message> messages_to_deliver_with_frame;
+  {
+    scoped_ptr<FrameSwapMessageQueue::SendMessageScope> send_message_scope =
+        frame_swap_message_queue_->AcquireSendMessageScope();
+    frame_swap_message_queue_->DrainMessages(&messages_to_deliver_with_frame);
+    if (!BrowserThread::CurrentlyOn(BrowserThread::UI)) {
+      BrowserThread::PostTask(
+          BrowserThread::UI,
+          FROM_HERE,
+          base::Bind(&SynchronousCompositorOutputSurface::DeliverMessages,
+                     weak_ptr_factory_.GetWeakPtr(),
+                     messages_to_deliver_with_frame));
+      return;
+    }
+  }
+  DeliverMessages(messages_to_deliver_with_frame);
 }
 
 void SynchronousCompositorOutputSurface::UpdateFrameMetaData(
     const cc::CompositorFrameMetadata& frame_info) {
   if (!BrowserThread::CurrentlyOn(BrowserThread::UI)) {
     BrowserThread::PostTask(
         BrowserThread::UI,
         FROM_HERE,
         base::Bind(&SynchronousCompositorOutputSurface::UpdateFrameMetaData,
                    weak_ptr_factory_.GetWeakPtr(),
                    frame_info));
     return;
   }
 
   SynchronousCompositorOutputSurfaceDelegate* delegate = GetDelegate();
   if (delegate)
     delegate->UpdateFrameMetaData(frame_info);
 }
 
+void SynchronousCompositorOutputSurface::DeliverMessages(
+    const std::vector<IPC::Message>& messages) {
+  DCHECK(CalledOnValidThread());
+  SynchronousCompositorOutputSurfaceDelegate* delegate = GetDelegate();
+  if (delegate)
+    delegate->DeliverMessages(messages);
+}
+
 namespace {
 void AdjustTransform(gfx::Transform* transform, gfx::Rect viewport) {
   // CC's draw origin starts at the viewport.
   transform->matrix().postTranslate(-viewport.x(), -viewport.y(), 0);
 }
 } // namespace
 
 bool SynchronousCompositorOutputSurface::InitializeHwDraw(
     scoped_refptr<cc::ContextProvider> onscreen_context_provider) {
   DCHECK(CalledOnValidThread());
@@ skipping 99 matching lines @@
 bool SynchronousCompositorOutputSurface::CalledOnValidThread() const {
   return BrowserThread::CurrentlyOn(BrowserThread::UI);
 }
 
 SynchronousCompositorOutputSurfaceDelegate*
 SynchronousCompositorOutputSurface::GetDelegate() {
   return SynchronousCompositorImpl::FromRoutingID(routing_id_);
 }
 
 }  // namespace content