exo: Handle cross-fade animations properly.

components/exo/surface.cc

 // Copyright 2015 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/exo/surface.h"
 
 #include <utility>
 
 #include "base/callback_helpers.h"
 #include "base/logging.h"
@@ skipping 174 matching lines @@
 
 ////////////////////////////////////////////////////////////////////////////////
 // Surface, public:
 
 Surface::Surface()
     : aura::Window(new CustomWindowDelegate(this)),
       has_pending_contents_(false),
       pending_input_region_(SkIRect::MakeLargest()),
       pending_buffer_scale_(1.0f),
       pending_only_visible_on_secure_output_(false),
+      only_visible_on_secure_output_(false),
       pending_blend_mode_(SkXfermode::kSrcOver_Mode),
       pending_alpha_(1.0f),
+      alpha_(1.0f),
       input_region_(SkIRect::MakeLargest()),
       needs_commit_surface_hierarchy_(false),
       update_contents_after_successful_compositing_(false),
       compositor_(nullptr),
       delegate_(nullptr) {
   SetType(ui::wm::WINDOW_TYPE_CONTROL);
   SetName("ExoSurface");
   SetProperty(kSurfaceKey, this);
   Init(ui::LAYER_SOLID_COLOR);
+  set_layer_owner_delegate(this);
   SetEventTargeter(base::WrapUnique(new CustomWindowTargeter));
   set_owned_by_parent(false);
   surface_manager_ =
       aura::Env::GetInstance()->context_factory()->GetSurfaceManager();
   if (use_surface_layer_) {
     factory_owner_ = make_scoped_refptr(new SurfaceFactoryOwner);
     factory_owner_->surface_ = this;
     factory_owner_->id_allocator_ =
         aura::Env::GetInstance()->context_factory()->CreateSurfaceIdAllocator();
     factory_owner_->surface_factory_.reset(
@@ skipping 203 matching lines @@
   TRACE_EVENT0("exo", "Surface::Commit");
 
   needs_commit_surface_hierarchy_ = true;
 
   if (delegate_)
     delegate_->OnSurfaceCommit();
   else
     CommitSurfaceHierarchy();
 }
 
-void Surface::CommitLayerContents() {
+void Surface::CommitTextureContents() {
   // We update contents if Attach() has been called since last commit.
   if (has_pending_contents_) {
     has_pending_contents_ = false;
 
     current_buffer_ = pending_buffer_;
     pending_buffer_.reset();
 
-    // TODO(dcastagna): Make secure_output_only a layer property instead of a
-    // texture mailbox flag so this can be changed without have to provide
-    // new contents.
-    bool secure_output_only = pending_only_visible_on_secure_output_;
-    pending_only_visible_on_secure_output_ = false;
-
     cc::TextureMailbox texture_mailbox;
     std::unique_ptr<cc::SingleReleaseCallback> texture_mailbox_release_callback;
     if (current_buffer_) {
       texture_mailbox_release_callback = current_buffer_->ProduceTextureMailbox(
-          &texture_mailbox, secure_output_only, false);
+          &texture_mailbox, only_visible_on_secure_output_,
+          false /* non_client_usage */);
     }
 
     // Update layer with the new contents.
     if (texture_mailbox_release_callback) {
       texture_size_in_dip_ = gfx::ScaleToFlooredSize(
           texture_mailbox.size_in_pixels(), 1.0f / pending_buffer_scale_);
       layer()->SetTextureMailbox(texture_mailbox,
                                  std::move(texture_mailbox_release_callback),
                                  texture_size_in_dip_);
       layer()->SetTextureFlipped(false);
@@ skipping 13 matching lines @@
   }
 
   if (layer()->has_external_content()) {
     // Determine the new surface size.
     // - Texture size in DIP defines the size if nothing else is set.
     // - If a viewport is set then that defines the size, otherwise
     //   the crop rectangle defines the size if set.
     gfx::Size contents_size = texture_size_in_dip_;
     if (!pending_viewport_.IsEmpty()) {
       contents_size = pending_viewport_;
-    } else if (!pending_crop_.IsEmpty()) {
-      DLOG_IF(WARNING, !gfx::IsExpressibleAsInt(pending_crop_.width()) ||
-                           !gfx::IsExpressibleAsInt(pending_crop_.height()))
-          << "Crop rectangle size (" << pending_crop_.size().ToString()
+    } else if (!crop_.IsEmpty()) {
+      DLOG_IF(WARNING, !gfx::IsExpressibleAsInt(crop_.width()) ||
+                           !gfx::IsExpressibleAsInt(crop_.height()))
+          << "Crop rectangle size (" << crop_.size().ToString()
           << ") most be expressible using integers when viewport is not set";
-      contents_size = gfx::ToCeiledSize(pending_crop_.size());
+      contents_size = gfx::ToCeiledSize(crop_.size());
     }
-    layer()->SetTextureCrop(pending_crop_);
+    layer()->SetTextureCrop(crop_);
     layer()->SetTextureScale(static_cast<float>(texture_size_in_dip_.width()) /
                                  contents_size.width(),
                              static_cast<float>(texture_size_in_dip_.height()) /
                                  contents_size.height());
+    layer()->SetTextureAlpha(alpha_);

[Daniele Castagna, 2016/06/06 02:47:53]

Is there any reason why you moved this before?

[reveman, 2016/06/06 03:17:36]

Not really. Just seemed a bit better to group the "Texture" related calls
together.

     layer()->SetBounds(gfx::Rect(layer()->bounds().origin(), contents_size));
-    layer()->SetTextureAlpha(pending_alpha_);
   }
 
   // Move pending frame callbacks to the end of |frame_callbacks_|.
   frame_callbacks_.splice(frame_callbacks_.end(), pending_frame_callbacks_);
 
   // Update alpha compositing properties.
   // TODO(reveman): Use a more reliable way to force blending off than setting
   // fills-bounds-opaquely.
   layer()->SetFillsBoundsOpaquely(
       pending_blend_mode_ == SkXfermode::kSrc_Mode ||
       pending_opaque_region_.contains(
           gfx::RectToSkIRect(gfx::Rect(layer()->size()))));
 }
 
 void Surface::CommitSurfaceContents() {
   // We update contents if Attach() has been called since last commit.
   if (has_pending_contents_) {
     has_pending_contents_ = false;
 
     current_buffer_ = pending_buffer_;
     pending_buffer_.reset();
 
-    bool secure_output_only = pending_only_visible_on_secure_output_;
-    pending_only_visible_on_secure_output_ = false;
-
     cc::TextureMailbox texture_mailbox;
     std::unique_ptr<cc::SingleReleaseCallback> texture_mailbox_release_callback;
     if (current_buffer_) {
       texture_mailbox_release_callback = current_buffer_->ProduceTextureMailbox(
-          &texture_mailbox, secure_output_only, false);
+          &texture_mailbox, only_visible_on_secure_output_,
+          false /* non_client_usage */);
     }
 
     cc::SurfaceId old_surface_id = surface_id_;
     surface_id_ = factory_owner_->id_allocator_->GenerateId();
     factory_owner_->surface_factory_->Create(surface_id_);
 
     gfx::Size buffer_size = texture_mailbox.size_in_pixels();
     gfx::SizeF scaled_buffer_size(
         gfx::ScaleSize(gfx::SizeF(buffer_size), 1.0f / pending_buffer_scale_));
 
     gfx::Size layer_size;  // Size of the output layer, in DIP.
     if (!pending_viewport_.IsEmpty()) {
       layer_size = pending_viewport_;
-    } else if (!pending_crop_.IsEmpty()) {
-      DLOG_IF(WARNING, !gfx::IsExpressibleAsInt(pending_crop_.width()) ||
-                           !gfx::IsExpressibleAsInt(pending_crop_.height()))
-          << "Crop rectangle size (" << pending_crop_.size().ToString()
+    } else if (!crop_.IsEmpty()) {
+      DLOG_IF(WARNING, !gfx::IsExpressibleAsInt(crop_.width()) ||
+                           !gfx::IsExpressibleAsInt(crop_.height()))
+          << "Crop rectangle size (" << crop_.size().ToString()
           << ") most be expressible using integers when viewport is not set";
-      layer_size = gfx::ToCeiledSize(pending_crop_.size());
+      layer_size = gfx::ToCeiledSize(crop_.size());
     } else {
       layer_size = gfx::ToCeiledSize(scaled_buffer_size);
     }
 
     // TODO(jbauman): Figure out how this interacts with the pixel size of
     // CopyOutputRequests on the layer.
     float contents_surface_to_layer_scale = 1.0;
     gfx::Size contents_surface_size = layer_size;
 
     gfx::PointF uv_top_left(0.f, 0.f);
     gfx::PointF uv_bottom_right(1.f, 1.f);
-    if (!pending_crop_.IsEmpty()) {
-      uv_top_left = pending_crop_.origin();
+    if (!crop_.IsEmpty()) {
+      uv_top_left = crop_.origin();
 
       uv_top_left.Scale(1.f / scaled_buffer_size.width(),
                         1.f / scaled_buffer_size.height());
-      uv_bottom_right = pending_crop_.bottom_right();
+      uv_bottom_right = crop_.bottom_right();
       uv_bottom_right.Scale(1.f / scaled_buffer_size.width(),
                             1.f / scaled_buffer_size.height());
     }
 
     // pending_damage_ is in Surface coordinates.
     gfx::Rect damage_rect = gfx::SkIRectToRect(pending_damage_.getBounds());
 
     std::unique_ptr<cc::RenderPass> render_pass = cc::RenderPass::Create();
     render_pass->SetAll(cc::RenderPassId(1, 1),
                         gfx::Rect(contents_surface_size), damage_rect,
                         gfx::Transform(), true);
 
     gfx::Rect quad_rect = gfx::Rect(contents_surface_size);
     cc::SharedQuadState* quad_state =
         render_pass->CreateAndAppendSharedQuadState();
     quad_state->quad_layer_bounds = contents_surface_size;
     quad_state->visible_quad_layer_rect = quad_rect;
-    quad_state->opacity = pending_alpha_;
+    quad_state->opacity = alpha_;
 
     bool frame_is_opaque = false;
 
     std::unique_ptr<cc::DelegatedFrameData> delegated_frame(
         new cc::DelegatedFrameData);
     if (texture_mailbox_release_callback) {
       cc::TransferableResource resource;
       resource.id = next_resource_id_++;
       resource.format = cc::RGBA_8888;
       resource.filter =
@@ skipping 13 matching lines @@
           pending_opaque_region_.contains(gfx::RectToSkIRect(quad_rect));
       if (frame_is_opaque) {
         opaque_rect = quad_rect;
       } else if (pending_opaque_region_.isRect()) {
         opaque_rect = gfx::SkIRectToRect(pending_opaque_region_.getBounds());
       }
 
       texture_quad->SetNew(quad_state, quad_rect, opaque_rect, quad_rect,
                            resource.id, true, uv_top_left, uv_bottom_right,
                            SK_ColorTRANSPARENT, vertex_opacity, false, false,
-                           secure_output_only);
+                           only_visible_on_secure_output_);
 
       factory_owner_->release_callbacks_[resource.id] = std::make_pair(
           factory_owner_, std::move(texture_mailbox_release_callback));
       delegated_frame->resource_list.push_back(resource);
     } else {
       cc::SolidColorDrawQuad* solid_quad =
           render_pass->CreateAndAppendDrawQuad<cc::SolidColorDrawQuad>();
       solid_quad->SetNew(quad_state, quad_rect, quad_rect, SK_ColorBLACK,
                          false);
       frame_is_opaque = true;
@@ skipping 11 matching lines @@
                                                                 old_surface_id);
       factory_owner_->surface_factory_->Destroy(old_surface_id);
     }
 
     layer()->SetShowSurface(
         surface_id_,
         base::Bind(&SatisfyCallback, base::Unretained(surface_manager_)),
         base::Bind(&RequireCallback, base::Unretained(surface_manager_)),
         contents_surface_size, contents_surface_to_layer_scale, layer_size);
     layer()->SetBounds(gfx::Rect(layer()->bounds().origin(), layer_size));
-    layer()->SetFillsBoundsOpaquely(pending_alpha_ == 1.0f && frame_is_opaque);
+    layer()->SetFillsBoundsOpaquely(alpha_ == 1.0f && frame_is_opaque);
 
     // Reset damage.
     pending_damage_.setEmpty();
   }
   // Move pending frame callbacks to the end of active_frame_callbacks_
   active_frame_callbacks_.splice(active_frame_callbacks_.end(),
                                  pending_frame_callbacks_);
 }
 
 void Surface::CommitSurfaceHierarchy() {
   DCHECK(needs_commit_surface_hierarchy_);
   needs_commit_surface_hierarchy_ = false;
 
+  // TODO(dcastagna): Make secure_output_only a layer property instead of a
+  // texture mailbox flag so this can be changed without have to provide
+  // new contents.
+  only_visible_on_secure_output_ = pending_only_visible_on_secure_output_;
+  pending_only_visible_on_secure_output_ = false;
+
+  // Update current alpha.
+  alpha_ = pending_alpha_;
+
+  // Update current crop rectangle.
+  crop_ = pending_crop_;
+
   if (factory_owner_) {
     CommitSurfaceContents();
   } else {
-    CommitLayerContents();
+    CommitTextureContents();
   }
 
   // Update current input region.
   input_region_ = pending_input_region_;
 
   // Synchronize window hierarchy. This will position and update the stacking
   // order of all sub-surfaces after committing all pending state of sub-surface
   // descendants.
   aura::Window* stacking_target = nullptr;
   for (auto& sub_surface_entry : pending_sub_surfaces_) {
@@ skipping 101 matching lines @@
 }
 
 void Surface::OnWindowRemovingFromRootWindow(aura::Window* window,
                                              aura::Window* new_root) {
   DCHECK(compositor_);
   compositor_->RemoveObserver(this);
   compositor_ = nullptr;
 }
 
 ////////////////////////////////////////////////////////////////////////////////
+// ui::LayerOwnerDelegate overrides:
+
+void Surface::OnLayerRecreated(ui::Layer* old_layer, ui::Layer* new_layer) {
+  if (!current_buffer_)
+    return;
+
+  // TODO(reveman): Give the client a chance to provide new contents.
+  if (factory_owner_) {
+    SetSurfaceLayerContents(new_layer);
+  } else {
+    SetTextureLayerContents(new_layer);
+  }
+}
+
+////////////////////////////////////////////////////////////////////////////////
 // ui::CompositorObserver overrides:
 
 void Surface::OnCompositingDidCommit(ui::Compositor* compositor) {
   DCHECK(!factory_owner_);
   // Move frame callbacks to the end of |active_frame_callbacks_|.
   active_frame_callbacks_.splice(active_frame_callbacks_.end(),
                                  frame_callbacks_);
 }
 
 void Surface::OnCompositingStarted(ui::Compositor* compositor,
@@ skipping 11 matching lines @@
   // Nothing more to do in here unless this has been set.
   if (!update_contents_after_successful_compositing_)
     return;
 
   update_contents_after_successful_compositing_ = false;
 
   // Early out if no contents is currently assigned to the surface.
   if (!current_buffer_)
     return;
 
-  // TODO(dcastagna): Make secure_output_only a layer property instead of a
-  // texture mailbox flag.
-  bool secure_output_only = false;
-
   // Update contents by producing a new texture mailbox for the current buffer.
-  cc::TextureMailbox texture_mailbox;
-  std::unique_ptr<cc::SingleReleaseCallback> texture_mailbox_release_callback =
-      current_buffer_->ProduceTextureMailbox(&texture_mailbox,
-                                             secure_output_only, true);
-  if (texture_mailbox_release_callback) {
-    layer()->SetTextureMailbox(texture_mailbox,
-                               std::move(texture_mailbox_release_callback),
-                               layer()->bounds().size());
-    layer()->SetTextureFlipped(false);
-    layer()->SchedulePaint(gfx::Rect(texture_mailbox.size_in_pixels()));
-  }
+  SetTextureLayerContents(layer());
 }
 
 void Surface::OnCompositingAborted(ui::Compositor* compositor) {
   // The contents of this surface might be lost if compositing aborted because
   // of a lost graphics context. We recover from this by updating the contents
   // of the surface next time the compositor successfully ends compositing.
   update_contents_after_successful_compositing_ = true;
 }
 
 void Surface::OnCompositingShuttingDown(ui::Compositor* compositor) {
   compositor->RemoveObserver(this);
   compositor_ = nullptr;
 }
 
 void Surface::WillDraw(cc::SurfaceId id) {
   while (!active_frame_callbacks_.empty()) {
     active_frame_callbacks_.front().Run(base::TimeTicks::Now());
     active_frame_callbacks_.pop_front();
   }
 }
 
+void Surface::SetTextureLayerContents(ui::Layer* layer) {
+  DCHECK(current_buffer_);
+
+  cc::TextureMailbox texture_mailbox;
+  std::unique_ptr<cc::SingleReleaseCallback> texture_mailbox_release_callback =
+      current_buffer_->ProduceTextureMailbox(&texture_mailbox,
+                                             only_visible_on_secure_output_,
+                                             true /* non_client_usage */);
+  if (!texture_mailbox_release_callback)
+    return;
+
+  layer->SetTextureMailbox(texture_mailbox,
+                           std::move(texture_mailbox_release_callback),
+                           texture_size_in_dip_);
+  layer->SetTextureFlipped(false);
+  layer->SetTextureCrop(crop_);
+  layer->SetTextureScale(static_cast<float>(texture_size_in_dip_.width()) /
+                             layer->bounds().width(),
+                         static_cast<float>(texture_size_in_dip_.height()) /
+                             layer->bounds().height());
+  layer->SetTextureAlpha(alpha_);
+}
+
+void Surface::SetSurfaceLayerContents(ui::Layer* layer) {
+  // TODO(jbauman): Implement this.
+  NOTIMPLEMENTED();
+}
+
 bool Surface::use_surface_layer_ = false;
 
 }  // namespace exo