Mandoline: Support transforms and clipping of OOPIFs and events

components/mus/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/mus/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"
@@ skipping 29 matching lines @@
 #elif defined(OS_ANDROID)
 #include "ui/platform_window/android/platform_window_android.h"
 #endif
 
 using mojo::Rect;
 using mojo::Size;
 
 namespace mus {
 namespace {
 
+// DrawViewTree recursively visits ServerViews, creating a SurfaceDrawQuad for
+// each that lacks one. For Views that already have CompositorFrames, we can
+// skip this step and let cc::SurfaceAggregator do the heavy lifting.
+// |skip_view| indicates whether or not we should generate a SurfaceDrawQuad
+// for the provided |view|.
 void DrawViewTree(cc::RenderPass* pass,
                   const ServerView* view,
                   const gfx::Vector2d& parent_to_root_origin_offset,
-                  float opacity) {
+                  float opacity,
+                  bool skip_view) {
   if (!view->visible())
     return;
 
   const gfx::Rect absolute_bounds =
       view->bounds() + parent_to_root_origin_offset;
+
   std::vector<const ServerView*> children(view->GetChildren());
+  // TODO(rjkroege, fsamuel): Make sure we're handling alpha correctly.
   const float combined_opacity = opacity * view->opacity();
-  for (std::vector<const ServerView*>::reverse_iterator it = children.rbegin();
-       it != children.rend(); ++it) {
+  for (auto it = children.rbegin(); it != children.rend(); ++it) {
     DrawViewTree(pass, *it, absolute_bounds.OffsetFromOrigin(),
-                 combined_opacity);
+                combined_opacity,
+                view->parent() &&
+                    !view->surface_id().is_null() /* skip_view */);
   }
 
+  if (skip_view || view->surface_id().is_null())
+    return;
+
   gfx::Transform quad_to_target_transform;
   quad_to_target_transform.Translate(absolute_bounds.x(), absolute_bounds.y());
-  const gfx::Rect bounds_at_origin(view->bounds().size());
+  gfx::Rect bounds_at_origin(view->bounds().size());
+
   cc::SharedQuadState* sqs = pass->CreateAndAppendSharedQuadState();
   // TODO(fsamuel): These clipping and visible rects are incorrect. They need
   // to be populated from CompositorFrame structs.
   sqs->SetAll(
       quad_to_target_transform, bounds_at_origin.size() /* layer_bounds */,
       bounds_at_origin /* visible_layer_bounds */,
       bounds_at_origin /* clip_rect */, false /* is_clipped */, view->opacity(),
       SkXfermode::kSrc_Mode, 0 /* sorting-context_id */);
 
   auto surface_quad = pass->CreateAndAppendDrawQuad<cc::SurfaceDrawQuad>();
@@ skipping 105 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;
 
-  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>());
-
-  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();
+  // TODO(fsamuel): We should add a trace for generating a top level frame.
+  scoped_ptr<cc::CompositorFrame> frame(GenerateCompositorFrame());
   frame_pending_ = true;
   if (top_level_display_client_) {
     top_level_display_client_->SubmitCompositorFrame(
         frame.Pass(), base::Bind(&DefaultDisplayManager::DidDraw,
                                  weak_factory_.GetWeakPtr()));
   }
   dirty_rect_ = gfx::Rect();
 }
 
 void DefaultDisplayManager::DidDraw() {
@@ skipping 21 matching lines @@
   mojo::ViewportMetrics old_metrics;
   old_metrics.size_in_pixels = metrics_.size_in_pixels.Clone();
   old_metrics.device_pixel_ratio = metrics_.device_pixel_ratio;
 
   metrics_.size_in_pixels = mojo::Size::From(size);
   metrics_.device_pixel_ratio = device_pixel_ratio;
 
   delegate_->OnViewportMetricsChanged(old_metrics, metrics_);
 }
 
+scoped_ptr<cc::CompositorFrame>
+DefaultDisplayManager::GenerateCompositorFrame() {
+  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>());
+
+  DrawViewTree(render_pass.get(),
+               delegate_->GetRootView(),
+               gfx::Vector2d(), 1.0f,
+               false /* skip_view */);
+
+  scoped_ptr<cc::DelegatedFrameData> frame_data(new cc::DelegatedFrameData);
+  frame_data->device_scale_factor = metrics_.device_pixel_ratio;
+  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();
+  return frame.Pass();
+}
+
+const cc::CompositorFrame*
+DefaultDisplayManager::GetLastCompositorFrame() const {
+  if (!top_level_display_client_)
+    return nullptr;
+
+  return top_level_display_client_->GetLastCompositorFrame();
+}
+
 void DefaultDisplayManager::OnBoundsChanged(const gfx::Rect& new_bounds) {
   UpdateMetrics(new_bounds.size(), metrics_.device_pixel_ratio);
 }
 
 void DefaultDisplayManager::OnDamageRect(const gfx::Rect& damaged_region) {
   dirty_rect_.Union(damaged_region);
   WantToDraw();
 }
 
 void DefaultDisplayManager::DispatchEvent(ui::Event* event) {
   mojo::EventPtr mojo_event(mojo::Event::From(*event));
-  delegate_->OnEvent(mojo_event.Pass());
+  ViewId id;
+  if (event->IsLocatedEvent() && !!top_level_display_client_) {

[sky, 2015/09/17 22:08:34]

As cc is updating during a draw cycle, might it be out of date when the event is
processed? For example, how do you know the view id is valid, or say didn't get
reused?

[Fady Samuel, 2015/09/17 22:13:11]

We are performing hit testing on the last display compositor frame. It is quite
possible that the ViewId no longer exists when we perform the hit test. We could
just drop it on the floor.

We could consider queuing up all ViewManager operations to execute once per
graphics frame followed by cc ops, followed by hit testing. Thoughts?

+    ui::LocatedEvent* located_event = static_cast<ui::LocatedEvent*>(event);
+    gfx::Point transformed_point;
+    cc::SurfaceId target_surface =
+        surfaces_state_->hit_tester()->GetTargetSurfaceAtPoint(
+            top_level_display_client_->surface_id(),
+            located_event->location(),
+            &transformed_point);
+    id = ViewIdFromTransportId(
+        cc::SurfaceIdAllocator::NamespaceForId(target_surface));
+    mojo_event->pointer_data->location->x = transformed_point.x();
+    mojo_event->pointer_data->location->y = transformed_point.y();
+  }
+  delegate_->OnEvent(id, mojo_event.Pass());
 
   switch (event->type()) {
     case ui::ET_MOUSE_PRESSED:
     case ui::ET_TOUCH_PRESSED:
       platform_window_->SetCapture();
       break;
     case ui::ET_MOUSE_RELEASED:
     case ui::ET_TOUCH_RELEASED:
       platform_window_->ReleaseCapture();
       break;
@@ skipping 21 matching lines @@
 
     DCHECK_EQ(key_press_event->GetCharacter(), char_event.GetCharacter());
     DCHECK_EQ(key_press_event->key_code(), char_event.key_code());
     DCHECK_EQ(key_press_event->flags(), char_event.flags());
 
     char_event.SetExtendedKeyEventData(
         make_scoped_ptr(new mojo::MojoExtendedKeyEventData(
             key_press_event->GetLocatedWindowsKeyboardCode(),
             key_press_event->GetText(), key_press_event->GetUnmodifiedText())));
 
-    delegate_->OnEvent(mojo::Event::From(char_event));
+    delegate_->OnEvent(id, mojo::Event::From(char_event));
   }
 #endif
 }
 
 void DefaultDisplayManager::OnCloseRequest() {
   platform_window_->Close();
 }
 
 void DefaultDisplayManager::OnClosed() {
   delegate_->OnDisplayClosed();
@@ skipping 10 matching lines @@
   if (widget != gfx::kNullAcceleratedWidget) {
     top_level_display_client_.reset(
         new TopLevelDisplayClient(widget, gpu_state_, surfaces_state_));
   }
   UpdateMetrics(metrics_.size_in_pixels.To<gfx::Size>(), device_pixel_ratio);
 }
 
 void DefaultDisplayManager::OnActivationChanged(bool active) {}
 
 }  // namespace mus