Move VISUAL_STATE promise to activation

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/auto_reset.h"
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/memory/singleton.h"
 #include "base/message_loop/message_loop.h"
 #include "base/metrics/histogram.h"
 #include "base/stl_util.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/sys_info.h"
 #include "base/trace_event/trace_event.h"
 #include "base/trace_event/trace_event_synthetic_delay.h"
 #include "build/build_config.h"
 #include "cc/base/switches.h"
 #include "cc/debug/benchmark_instrumentation.h"
 #include "cc/output/output_surface.h"
+#include "cc/output/promise.h"
 #include "cc/trees/layer_tree_host.h"
 #include "content/child/npapi/webplugin.h"
 #include "content/common/gpu/client/context_provider_command_buffer.h"
 #include "content/common/gpu/client/webgraphicscontext3d_command_buffer_impl.h"
 #include "content/common/gpu/gpu_process_launch_causes.h"
 #include "content/common/input/synthetic_gesture_packet.h"
 #include "content/common/input/web_input_event_traits.h"
 #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/frame_update_message_queue.h"
 #include "content/renderer/gpu/mailbox_output_surface.h"
+#include "content/renderer/gpu/queue_message_activation_promise.h"
 #include "content/renderer/gpu/queue_message_swap_promise.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_frame_proxy.h"
 #include "content/renderer/render_process.h"
 #include "content/renderer/render_thread_impl.h"
 #include "content/renderer/renderer_blink_platform_impl.h"
@@ skipping 455 matching lines @@
       screen_info_(screen_info),
       device_scale_factor_(screen_info_.deviceScaleFactor),
       current_event_latency_info_(NULL),
       next_output_surface_id_(0),
 #if defined(OS_ANDROID)
       text_field_is_dirty_(false),
       outstanding_ime_acks_(0),
       body_background_color_(SK_ColorWHITE),
 #endif
       popup_origin_scale_for_emulation_(0.f),
-      frame_swap_message_queue_(new FrameSwapMessageQueue()),
+      frame_update_message_queue_(new FrameUpdateMessageQueue()),
       resizing_mode_selector_(new ResizingModeSelector()),
       context_menu_source_type_(ui::MENU_SOURCE_MOUSE),
       has_host_context_menu_location_(false) {
   if (!swapped_out)
     RenderProcess::current()->AddRefProcess();
   DCHECK(RenderThread::Get());
   device_color_profile_.push_back('0');
 }
 
 RenderWidget::~RenderWidget() {
@@ skipping 463 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(),
-                                        frame_swap_message_queue_);
+                                        frame_update_message_queue_);
   }
 #endif
 
   const base::CommandLine& command_line =
       *base::CommandLine::ForCurrentProcess();
   bool use_software = fallback;
   if (command_line.HasSwitch(switches::kDisableGpuCompositing))
     use_software = true;
 
   scoped_refptr<ContextProviderCommandBuffer> context_provider;
@@ skipping 12 matching lines @@
       // 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(compositor_deps_->GetCompositorImplThreadTaskRunner());
     return scoped_ptr<cc::OutputSurface>(new DelegatedCompositorOutputSurface(
         routing_id(), output_surface_id, context_provider,
-        worker_context_provider, frame_swap_message_queue_));
+        worker_context_provider, frame_update_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, nullptr, nullptr,
-        software_device.Pass(), frame_swap_message_queue_, true));
+        software_device.Pass(), frame_update_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(RenderThreadImpl::current()->layout_test_mode());
     cc::ResourceFormat format = cc::RGBA_8888;
     if (base::SysInfo::IsLowEndDevice())
       format = cc::RGB_565;
     return scoped_ptr<cc::OutputSurface>(new MailboxOutputSurface(
         routing_id(), output_surface_id, context_provider,
         worker_context_provider, scoped_ptr<cc::SoftwareOutputDevice>(),
-        frame_swap_message_queue_, format));
+        frame_update_message_queue_, format));
   }
   bool use_swap_compositor_frame_message = false;
   return scoped_ptr<cc::OutputSurface>(new CompositorOutputSurface(
       routing_id(), output_surface_id, context_provider,
       worker_context_provider, scoped_ptr<cc::SoftwareOutputDevice>(),
-      frame_swap_message_queue_, use_swap_compositor_frame_message));
+      frame_update_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 341 matching lines @@
                     DidCommitCompositorFrame());
   FOR_EACH_OBSERVER(RenderFrameProxy, render_frame_proxies_,
                     DidCommitCompositorFrame());
 #if defined(VIDEO_HOLE)
   FOR_EACH_OBSERVER(RenderFrameImpl, video_hole_frames_,
                     DidCommitCompositorFrame());
 #endif  // defined(VIDEO_HOLE)
 }
 
 // static
-scoped_ptr<cc::SwapPromise> RenderWidget::QueueMessageImpl(
+scoped_ptr<cc::Promise> RenderWidget::QueueMessageImpl(
     IPC::Message* msg,
     MessageDeliveryPolicy policy,
-    FrameSwapMessageQueue* frame_swap_message_queue,
+    FrameUpdateMessageQueue* frame_update_message_queue,
     scoped_refptr<IPC::SyncMessageFilter> sync_message_filter,
     int source_frame_number) {
   bool first_message_for_frame = false;
-  frame_swap_message_queue->QueueMessageForFrame(policy,
+  frame_update_message_queue->QueueMessageForFrame(policy,
                                                  source_frame_number,
                                                  make_scoped_ptr(msg),
                                                  &first_message_for_frame);
+  scoped_ptr<cc::Promise> promise;
   if (first_message_for_frame) {
-    scoped_ptr<cc::SwapPromise> promise(new QueueMessageSwapPromise(
-        sync_message_filter, frame_swap_message_queue, source_frame_number));
-    return promise;
+    switch (policy) {
+    case MESSAGE_DELIVERY_POLICY_WITH_VISUAL_STATE:
+    case MESSAGE_DELIVERY_POLICY_WITH_ACTIVATION:
+      promise.reset(new QueueMessageActivationPromise(
+          sync_message_filter, frame_update_message_queue,
+          source_frame_number));
+    case MESSAGE_DELIVERY_POLICY_WITH_NEXT_SWAP:
+      promise.reset(new QueueMessageSwapPromise(sync_message_filter,
+                                                frame_update_message_queue,
+                                                source_frame_number));
+      break;
+    }
   }
-  return nullptr;
+  return promise;
 }
 
 void RenderWidget::QueueMessage(IPC::Message* msg,
                                 MessageDeliveryPolicy policy) {
   // RenderThreadImpl::current() is NULL in some tests.
   if (!compositor_ || !RenderThreadImpl::current()) {
     Send(msg);
     return;
   }
 
-  scoped_ptr<cc::SwapPromise> swap_promise =
+  scoped_ptr<cc::Promise> promise =
       QueueMessageImpl(msg,
                        policy,
-                       frame_swap_message_queue_.get(),
+                       frame_update_message_queue_.get(),
                        RenderThreadImpl::current()->sync_message_filter(),
                        compositor_->GetSourceFrameNumber());
 
-  if (swap_promise) {
-    compositor_->QueueSwapPromise(swap_promise.Pass());
+  if (promise) {
+    compositor_->QueuePromise(promise.Pass());
     // Request a commit. This might either A) request a commit ahead of time
     // or B) request a commit which is not needed because there are not
     // pending updates. If B) then the commit will be skipped and the swap
     // promises will be broken (see EarlyOut_NoUpdates). To achieve that we
     // call SetNeedsUpdateLayers instead of SetNeedsCommit so that
     // can_cancel_commit is not unset.
     compositor_->SetNeedsUpdateLayers();
   }
 }
 
@@ skipping 969 matching lines @@
 void RenderWidget::RegisterVideoHoleFrame(RenderFrameImpl* frame) {
   video_hole_frames_.AddObserver(frame);
 }
 
 void RenderWidget::UnregisterVideoHoleFrame(RenderFrameImpl* frame) {
   video_hole_frames_.RemoveObserver(frame);
 }
 #endif  // defined(VIDEO_HOLE)
 
 }  // namespace content