Deliver IPC messages together with SwapCompositorFrame

content/renderer/render_widget.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/render_widget.h"
 
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/debug/trace_event.h"
 #include "base/debug/trace_event_synthetic_delay.h"
@@ skipping 18 matching lines @@
 #include "content/common/input_messages.h"
 #include "content/common/swapped_out_messages.h"
 #include "content/common/view_messages.h"
 #include "content/public/common/content_switches.h"
 #include "content/public/common/context_menu_params.h"
 #include "content/renderer/cursor_utils.h"
 #include "content/renderer/external_popup_menu.h"
 #include "content/renderer/gpu/compositor_output_surface.h"
 #include "content/renderer/gpu/compositor_software_output_device.h"
 #include "content/renderer/gpu/delegated_compositor_output_surface.h"
+#include "content/renderer/gpu/frame_swap_message_queue.h"
 #include "content/renderer/gpu/mailbox_output_surface.h"
 #include "content/renderer/gpu/render_widget_compositor.h"
 #include "content/renderer/ime_event_guard.h"
 #include "content/renderer/input/input_handler_manager.h"
 #include "content/renderer/pepper/pepper_plugin_instance_impl.h"
 #include "content/renderer/render_frame_impl.h"
 #include "content/renderer/render_process.h"
 #include "content/renderer/render_thread_impl.h"
 #include "content/renderer/renderer_webkitplatformsupport_impl.h"
 #include "content/renderer/resizing_mode_selector.h"
@@ skipping 97 matching lines @@
     return ui::TEXT_INPUT_MODE_DEFAULT;
   return it->second;
 }
 
 // TODO(brianderson): Replace the hard-coded threshold with a fraction of
 // the BeginMainFrame interval.
 // 4166us will allow 1/4 of a 60Hz interval or 1/2 of a 120Hz interval to
 // be spent in input hanlders before input starts getting throttled.
 const int kInputHandlingTimeThrottlingThresholdMicroseconds = 4166;
 
+class QueueMessageSwapPromise : public cc::SwapPromise {
+ public:
+  QueueMessageSwapPromise(
+      scoped_refptr<IPC::SyncMessageFilter> message_sender,
+      scoped_refptr<content::FrameSwapMessageQueue> message_queue,
+      IPC::Message* msg)
+      : message_sender_(message_sender),
+        message_queue_(message_queue),
+        msg_(msg) {
+    DCHECK(message_sender_.get());
+    DCHECK(message_queue_.get());
+    DCHECK(msg);
+  }
+
+  virtual ~QueueMessageSwapPromise() {
+    // The promise should have either been kept or broken before it's deleted.
+    DCHECK(!msg_);
+  }
+
+  virtual void DidSwap(cc::CompositorFrameMetadata* metadata) OVERRIDE {
+    message_queue_->QueueMessage(msg_);
+    msg_ = NULL;
+  }
+
+  virtual void DidNotSwap(DidNotSwapReason reason) OVERRIDE {
+    message_sender_->Send(msg_);
+    msg_ = NULL;
+  }
+
+ private:
+  scoped_refptr<IPC::SyncMessageFilter> message_sender_;
+  scoped_refptr<content::FrameSwapMessageQueue> message_queue_;
+  IPC::Message* msg_;
+};
+
 }  // namespace
 
 namespace content {
 
 // RenderWidget::ScreenMetricsEmulator ----------------------------------------
 
 class RenderWidget::ScreenMetricsEmulator {
  public:
   ScreenMetricsEmulator(
       RenderWidget* widget,
@@ skipping 224 matching lines @@
 #if defined(OS_ANDROID)
       text_field_is_dirty_(false),
       outstanding_ime_acks_(0),
       body_background_color_(SK_ColorWHITE),
 #endif
 #if defined(OS_MACOSX)
       cached_has_main_frame_horizontal_scrollbar_(false),
       cached_has_main_frame_vertical_scrollbar_(false),
 #endif
       popup_origin_scale_for_emulation_(0.f),
+      frame_swap_message_queue_(new FrameSwapMessageQueue()),
       resizing_mode_selector_(new ResizingModeSelector()),
       context_menu_source_type_(ui::MENU_SOURCE_MOUSE) {
   if (!swapped_out)
     RenderProcess::current()->AddRefProcess();
   DCHECK(RenderThread::Get());
   is_threaded_compositing_enabled_ =
       CommandLine::ForCurrentProcess()->HasSwitch(
           switches::kEnableThreadedCompositing);
 }
 
@@ skipping 397 matching lines @@
 }
 
 scoped_ptr<cc::OutputSurface> RenderWidget::CreateOutputSurface(bool fallback) {
   // For widgets that are never visible, we don't start the compositor, so we
   // never get a request for a cc::OutputSurface.
   DCHECK(!never_visible_);
 
 #if defined(OS_ANDROID)
   if (SynchronousCompositorFactory* factory =
       SynchronousCompositorFactory::GetInstance()) {
-    return factory->CreateOutputSurface(routing_id());
+    return factory->CreateOutputSurface(routing_id(),
+                                        frame_swap_message_queue_);
   }
 #endif
 
   const CommandLine& command_line = *CommandLine::ForCurrentProcess();
   bool use_software = fallback;
   if (command_line.HasSwitch(switches::kDisableGpuCompositing))
     use_software = true;
 
   scoped_refptr<ContextProviderCommandBuffer> context_provider;
   if (!use_software) {
     context_provider = ContextProviderCommandBuffer::Create(
         CreateGraphicsContext3D(), "RenderCompositor");
     if (!context_provider.get()) {
       // Cause the compositor to wait and try again.
       return scoped_ptr<cc::OutputSurface>();
     }
   }
 
   uint32 output_surface_id = next_output_surface_id_++;
   if (command_line.HasSwitch(switches::kEnableDelegatedRenderer)) {
     DCHECK(is_threaded_compositing_enabled_);
     return scoped_ptr<cc::OutputSurface>(
-        new DelegatedCompositorOutputSurface(
-            routing_id(),
-            output_surface_id,
-            context_provider));
+        new DelegatedCompositorOutputSurface(routing_id(),
+                                             output_surface_id,
+                                             context_provider,
+                                             frame_swap_message_queue_));
   }
   if (!context_provider.get()) {
     scoped_ptr<cc::SoftwareOutputDevice> software_device(
         new CompositorSoftwareOutputDevice());
 
-    return scoped_ptr<cc::OutputSurface>(new CompositorOutputSurface(
-        routing_id(),
-        output_surface_id,
-        NULL,
-        software_device.Pass(),
-        true));
+    return scoped_ptr<cc::OutputSurface>(
+        new CompositorOutputSurface(routing_id(),
+                                    output_surface_id,
+                                    NULL,
+                                    software_device.Pass(),
+                                    frame_swap_message_queue_,
+                                    true));
   }
 
   if (command_line.HasSwitch(cc::switches::kCompositeToMailbox)) {
     // Composite-to-mailbox is currently used for layout tests in order to cause
     // them to draw inside in the renderer to do the readback there. This should
     // no longer be the case when crbug.com/311404 is fixed.
     DCHECK(is_threaded_compositing_enabled_ ||
            RenderThreadImpl::current()->layout_test_mode());
     cc::ResourceFormat format = cc::RGBA_8888;
 #if defined(OS_ANDROID)
     if (base::android::SysUtils::IsLowEndDevice())
       format = cc::RGB_565;
 #endif
     return scoped_ptr<cc::OutputSurface>(
-        new MailboxOutputSurface(
-            routing_id(),
-            output_surface_id,
-            context_provider,
-            scoped_ptr<cc::SoftwareOutputDevice>(),
-            format));
+        new MailboxOutputSurface(routing_id(),
+                                 output_surface_id,
+                                 context_provider,
+                                 scoped_ptr<cc::SoftwareOutputDevice>(),
+                                 frame_swap_message_queue_,
+                                 format));
   }
   bool use_swap_compositor_frame_message = false;
   return scoped_ptr<cc::OutputSurface>(
-      new CompositorOutputSurface(
-          routing_id(),
-          output_surface_id,
-          context_provider,
-          scoped_ptr<cc::SoftwareOutputDevice>(),
-          use_swap_compositor_frame_message));
+      new CompositorOutputSurface(routing_id(),
+                                  output_surface_id,
+                                  context_provider,
+                                  scoped_ptr<cc::SoftwareOutputDevice>(),
+                                  frame_swap_message_queue_,
+                                  use_swap_compositor_frame_message));
 }
 
 void RenderWidget::OnSwapBuffersAborted() {
   TRACE_EVENT0("renderer", "RenderWidget::OnSwapBuffersAborted");
   // Schedule another frame so the compositor learns about it.
   scheduleComposite();
 }
 
 void RenderWidget::OnSwapBuffersPosted() {
   TRACE_EVENT0("renderer", "RenderWidget::OnSwapBuffersPosted");
@@ skipping 307 matching lines @@
 void RenderWidget::didBecomeReadyForAdditionalInput() {
   TRACE_EVENT0("renderer", "RenderWidget::didBecomeReadyForAdditionalInput");
   FlushPendingInputEventAck();
 }
 
 void RenderWidget::DidCommitCompositorFrame() {
   FOR_EACH_OBSERVER(RenderFrameImpl, swapped_out_frames_,
                     DidCommitCompositorFrame());
 }
 
+namespace {}  //  namespace
+
+void RenderWidget::QueueMessage(IPC::Message* msg,
+                                MessageDeliveryPolicy policy) {
+  if (!compositor_) {
+    Send(msg);
+    return;
+  }
+
+  if (policy == MESSAGE_DELIVERY_POLICY_WITH_NEXT_SWAP) {
+    frame_swap_message_queue_->QueueMessage(msg);
+    return;
+  }
+
+  if (policy == MESSAGE_DELIVERY_POLICY_WITH_VISUAL_STATE &&
+      !compositor_->commitRequested()) {
+    scoped_ptr<FrameSwapMessageQueue::SendMessageScope> send_message_scope =
+        frame_swap_message_queue_->AcquireSendMessageScope();
+    Send(msg);
+    return;
+  }
+
+  DCHECK(policy == MESSAGE_DELIVERY_POLICY_WITH_VISUAL_STATE ||
+         policy == MESSAGE_DELIVERY_POLICY_WITH_NEXT_COMMIT);
+  scoped_ptr<cc::SwapPromise> promise(new QueueMessageSwapPromise(
+      RenderThreadImpl::current()->sync_message_filter(),
+      frame_swap_message_queue_,
+      msg));
+  compositor_->QueueSwapPromise(promise.Pass());
+}
+
 void RenderWidget::didCommitAndDrawCompositorFrame() {
   TRACE_EVENT0("gpu", "RenderWidget::didCommitAndDrawCompositorFrame");
   // Accelerated FPS tick for performance tests. See
   // tab_capture_performancetest.cc.  NOTE: Tests may break if this event is
   // renamed or moved.
   UNSHIPPED_TRACE_EVENT_INSTANT0("test_fps", "TestFrameTickGPU",
                                  TRACE_EVENT_SCOPE_THREAD);
   // Notify subclasses that we initiated the paint operation.
   DidInitiatePaint();
 }
@@ skipping 853 matching lines @@
 
 void RenderWidget::RegisterSwappedOutChildFrame(RenderFrameImpl* frame) {
   swapped_out_frames_.AddObserver(frame);
 }
 
 void RenderWidget::UnregisterSwappedOutChildFrame(RenderFrameImpl* frame) {
   swapped_out_frames_.RemoveObserver(frame);
 }
 
 }  // namespace content