Mandoline: Allow submitting CompositorFrames directly to mojo::Views

components/view_manager/display_manager.cc

 // Copyright 2014 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 "components/view_manager/display_manager.h"
 
 #include "base/numerics/safe_conversions.h"
+#include "cc/output/compositor_frame.h"
+#include "cc/output/delegated_frame_data.h"
+#include "cc/quads/render_pass.h"
+#include "cc/quads/shared_quad_state.h"
+#include "cc/quads/surface_draw_quad.h"
 #include "components/view_manager/display_manager_factory.h"
 #include "components/view_manager/gles2/gpu_state.h"
 #include "components/view_manager/public/interfaces/gpu.mojom.h"
 #include "components/view_manager/public/interfaces/quads.mojom.h"
 #include "components/view_manager/public/interfaces/surfaces.mojom.h"
 #include "components/view_manager/server_view.h"
 #include "components/view_manager/surfaces/surfaces_state.h"
 #include "components/view_manager/view_coordinate_conversions.h"
 #include "mojo/application/public/cpp/application_connection.h"
 #include "mojo/application/public/cpp/application_impl.h"
 #include "mojo/converters/geometry/geometry_type_converters.h"
 #include "mojo/converters/input_events/input_events_type_converters.h"
 #include "mojo/converters/input_events/mojo_extended_key_event_data.h"
 #include "mojo/converters/surfaces/surfaces_type_converters.h"
 #include "mojo/converters/surfaces/surfaces_utils.h"
 #include "mojo/converters/transform/transform_type_converters.h"
+#include "third_party/skia/include/core/SkXfermode.h"
 #include "ui/events/event.h"
 #include "ui/events/event_utils.h"
 #include "ui/platform_window/platform_ime_controller.h"
 #include "ui/platform_window/platform_window.h"
 #include "ui/platform_window/stub/stub_window.h"
 
 #if defined(OS_WIN)
 #include "ui/platform_window/win/win_window.h"
 #elif defined(USE_X11)
 #include "ui/platform_window/x11/x11_window.h"
 #elif defined(OS_ANDROID)
 #include "ui/platform_window/android/platform_window_android.h"
 #endif
 
 using mojo::Rect;
 using mojo::Size;
 
 namespace view_manager {
 namespace {
 
-void DrawViewTree(mojo::Pass* pass,
+void DrawViewTree(cc::RenderPass* pass,
                   const ServerView* view,
                   const gfx::Vector2d& parent_to_root_origin_offset,
                   float opacity) {
   if (!view->visible())
     return;
 
   const gfx::Rect absolute_bounds =
       view->bounds() + parent_to_root_origin_offset;
   std::vector<const ServerView*> children(view->GetChildren());
   const float combined_opacity = opacity * view->opacity();
   for (std::vector<const ServerView*>::reverse_iterator it = children.rbegin();
        it != children.rend();
        ++it) {
     DrawViewTree(pass, *it, absolute_bounds.OffsetFromOrigin(),
                  combined_opacity);
   }
 
-  cc::SurfaceId node_id = view->surface_id();
-
-  auto surface_quad_state = mojo::SurfaceQuadState::New();
-  surface_quad_state->surface = mojo::SurfaceId::From(node_id);
-
   gfx::Transform node_transform;
   node_transform.Translate(absolute_bounds.x(), absolute_bounds.y());
+  cc::SharedQuadState* sqs = pass->CreateAndAppendSharedQuadState();
+  sqs->SetAll(node_transform /* quad_to_target_transform */,
+              view->bounds().size() /* layer_bounds */,
+              gfx::Rect(view->bounds().size()) /* visible_layer_rect */,
+              gfx::Rect(view->bounds().size()) /* clip_rect */,
+              false /* is_clipped */,
+              view->opacity() /* opacity */,
+              SkXfermode::kSrc_Mode,
+              0 /* sorting-context_id */);
 
   const gfx::Rect bounds_at_origin(view->bounds().size());
-  auto surface_quad = mojo::Quad::New();
-  surface_quad->material = mojo::Material::MATERIAL_SURFACE_CONTENT;
-  surface_quad->rect = Rect::From(bounds_at_origin);
-  surface_quad->opaque_rect = Rect::From(bounds_at_origin);
-  surface_quad->visible_rect = Rect::From(bounds_at_origin);
-  surface_quad->needs_blending = true;
-  surface_quad->shared_quad_state_index =
-      base::saturated_cast<int32_t>(pass->shared_quad_states.size());
-  surface_quad->surface_quad_state = surface_quad_state.Pass();
-
-  auto sqs = mojo::CreateDefaultSQS(view->bounds().size());
-  sqs->blend_mode = mojo::SK_XFERMODE_kSrcOver_Mode;
-  sqs->opacity = combined_opacity;
-  sqs->quad_to_target_transform = mojo::Transform::From(node_transform);
-
-  pass->quads.push_back(surface_quad.Pass());
-  pass->shared_quad_states.push_back(sqs.Pass());
+  auto surface_quad =
+      pass->CreateAndAppendDrawQuad<cc::SurfaceDrawQuad>();
+  surface_quad->SetNew(sqs,
+                       bounds_at_origin /* rect */,
+                       bounds_at_origin /* visible_rect */,
+                       view->surface_id());
 }
 
 float ConvertUIWheelValueToMojoValue(int offset) {
   // Mojo's event type takes a value between -1 and 1. Normalize by allowing
   // up to 20 of ui's offset. This is a bit arbitrary.
   return std::max(
       -1.0f, std::min(1.0f, static_cast<float>(offset) /
                                 (20 * static_cast<float>(
                                           ui::MouseWheelEvent::kWheelDelta))));
 }
@@ skipping 96 matching lines @@
 
 void DefaultDisplayManager::SetImeVisibility(bool visible) {
   ui::PlatformImeController* ime = platform_window_->GetPlatformImeController();
   if (ime)
     ime->SetImeVisibility(visible);
 }
 
 void DefaultDisplayManager::Draw() {
   if (!delegate_->GetRootView()->visible())
     return;
-  gfx::Rect rect(metrics_.size_in_pixels.To<gfx::Size>());
-  auto pass = mojo::CreateDefaultPass(1, rect);
-  pass->damage_rect = Rect::From(dirty_rect_);
 
-  DrawViewTree(pass.get(), delegate_->GetRootView(), gfx::Vector2d(), 1.0f);
+  scoped_ptr<cc::RenderPass> render_pass = cc::RenderPass::Create();
+  render_pass->damage_rect = dirty_rect_;
+  render_pass->output_rect = gfx::Rect(metrics_.size_in_pixels.To<gfx::Size>());
 
-  auto frame = mojo::Frame::New();
-  frame->passes.push_back(pass.Pass());
-  frame->resources.resize(0u);
+  DrawViewTree(render_pass.get(),
+               delegate_->GetRootView(),
+               gfx::Vector2d(), 1.0f);
+
+  scoped_ptr<cc::DelegatedFrameData> frame_data(new cc::DelegatedFrameData);
+  frame_data->device_scale_factor = 1.f;
+  frame_data->render_pass_list.push_back(render_pass.Pass());
+
+  scoped_ptr<cc::CompositorFrame> frame(new cc::CompositorFrame);
+  frame->delegated_frame_data = frame_data.Pass();
   frame_pending_ = true;
   if (top_level_display_client_) {
     top_level_display_client_->SubmitFrame(
         frame.Pass(),
         base::Bind(&DefaultDisplayManager::DidDraw, base::Unretained(this)));
   }
   dirty_rect_ = gfx::Rect();
 }
 
 void DefaultDisplayManager::DidDraw() {
@@ skipping 115 matching lines @@
     float device_pixel_ratio) {
   top_level_display_client_.reset(
       new surfaces::TopLevelDisplayClient(widget, gpu_state_, surfaces_state_));
   UpdateMetrics(metrics_.size_in_pixels.To<gfx::Size>(), device_pixel_ratio);
 }
 
 void DefaultDisplayManager::OnActivationChanged(bool active) {
 }
 
 }  // namespace view_manager