exo: Allow updating cc::Surface viewport and crop state independently.

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 370 matching lines @@
 
   DCHECK(ListContainsEntry(pending_sub_surfaces_, sub_surface));
   pending_sub_surfaces_.splice(
       sibling_it, pending_sub_surfaces_,
       FindListEntry(pending_sub_surfaces_, sub_surface));
 }
 
 void Surface::SetViewport(const gfx::Size& viewport) {
   TRACE_EVENT1("exo", "Surface::SetViewport", "viewport", viewport.ToString());
 
+  if (pending_viewport_ == viewport)
+    return;
+
   pending_viewport_ = viewport;
+  changed_viewport_or_crop_ = true;
 }
 
 void Surface::SetCrop(const gfx::RectF& crop) {
   TRACE_EVENT1("exo", "Surface::SetCrop", "crop", crop.ToString());
 
+  if (pending_crop_ == crop)
+    return;
+
   pending_crop_ = crop;
+  changed_viewport_or_crop_ = true;
 }
 
 void Surface::SetOnlyVisibleOnSecureOutput(bool only_visible_on_secure_output) {
   TRACE_EVENT1("exo", "Surface::SetOnlyVisibleOnSecureOutput",
                "only_visible_on_secure_output", only_visible_on_secure_output);
 
   pending_only_visible_on_secure_output_ = only_visible_on_secure_output;
 }
 
 void Surface::SetBlendMode(SkXfermode::Mode blend_mode) {
@@ skipping 97 matching lines @@
   // 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;
+    if (current_buffer_) {
+      std::unique_ptr<cc::SingleReleaseCallback>
+          texture_mailbox_release_callback;
 
-    cc::TextureMailbox texture_mailbox;
-    std::unique_ptr<cc::SingleReleaseCallback> texture_mailbox_release_callback;
-    if (current_buffer_) {
+      cc::TextureMailbox texture_mailbox;
       texture_mailbox_release_callback = current_buffer_->ProduceTextureMailbox(
-          &texture_mailbox, secure_output_only, false);
+          &texture_mailbox, pending_only_visible_on_secure_output_, false);
+      cc::TransferableResource resource;
+      resource.id = next_resource_id_++;
+      resource.format = cc::RGBA_8888;
+      resource.filter =
+          texture_mailbox.nearest_neighbor() ? GL_NEAREST : GL_LINEAR;
+      resource.size = texture_mailbox.size_in_pixels();
+      resource.mailbox_holder = gpu::MailboxHolder(texture_mailbox.mailbox(),
+                                                   texture_mailbox.sync_token(),
+                                                   texture_mailbox.target());
+      resource.is_overlay_candidate = texture_mailbox.is_overlay_candidate();
+
+      factory_owner_->release_callbacks_[resource.id] = std::make_pair(
+          factory_owner_, std::move(texture_mailbox_release_callback));
+      current_resource_ = resource;
+    } else {
+      current_resource_.id = 0;
+      current_resource_.size = gfx::Size();
     }
+  }
+
+  if (has_pending_contents_ || changed_viewport_or_crop_) {

[reveman, 2016/06/03 19:06:51]

Do we need this if statement and the new changed_viewport_or_crop_ member? It's
rare that we get a commit but haven't changed contents or clipping and I'm not
sure it's worth optimizing for it at this time.

+    has_pending_contents_ = false;
+    changed_viewport_or_crop_ = false;
 
     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::Size buffer_size = current_resource_.size;
     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()
@@ skipping 33 matching lines @@
         render_pass->CreateAndAppendSharedQuadState();
     quad_state->quad_layer_bounds = contents_surface_size;
     quad_state->visible_quad_layer_rect = quad_rect;
     quad_state->opacity = alpha_;
     alpha_ = pending_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 =
-          texture_mailbox.nearest_neighbor() ? GL_NEAREST : GL_LINEAR;
-      resource.size = texture_mailbox.size_in_pixels();
-      resource.mailbox_holder = gpu::MailboxHolder(texture_mailbox.mailbox(),
-                                                   texture_mailbox.sync_token(),
-                                                   texture_mailbox.target());
-      resource.is_overlay_candidate = texture_mailbox.is_overlay_candidate();
-
+    if (current_resource_.id) {
       cc::TextureDrawQuad* texture_quad =
           render_pass->CreateAndAppendDrawQuad<cc::TextureDrawQuad>();
       float vertex_opacity[4] = {1.0, 1.0, 1.0, 1.0};
       gfx::Rect opaque_rect;
       frame_is_opaque =
           pending_blend_mode_ == SkXfermode::kSrc_Mode ||
           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);
-
-      factory_owner_->release_callbacks_[resource.id] = std::make_pair(
-          factory_owner_, std::move(texture_mailbox_release_callback));
-      delegated_frame->resource_list.push_back(resource);
+      texture_quad->SetNew(
+          quad_state, quad_rect, opaque_rect, quad_rect, current_resource_.id,
+          true, uv_top_left, uv_bottom_right, SK_ColorTRANSPARENT,
+          vertex_opacity, false, false, pending_only_visible_on_secure_output_);
+      delegated_frame->resource_list.push_back(current_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;
     }
 
     delegated_frame->render_pass_list.push_back(std::move(render_pass));
     std::unique_ptr<cc::CompositorFrame> frame(new cc::CompositorFrame);
@@ skipping 12 matching lines @@
         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(alpha_ == 1.0f && frame_is_opaque);
 
     // Reset damage.
     pending_damage_.setEmpty();
   }
+
+  if (current_resource_.id)

[reveman, 2016/06/03 19:06:50]

nit: please include this in the DCHECK, DCHECK(!current_resource_.id || ...

+    DCHECK(factory_owner_->release_callbacks_.count(current_resource_.id));
+
   // 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;
 
   if (factory_owner_) {
@@ skipping 201 matching lines @@
 void Surface::WillDraw(cc::SurfaceId id) {
   while (!active_frame_callbacks_.empty()) {
     active_frame_callbacks_.front().Run(base::TimeTicks::Now());
     active_frame_callbacks_.pop_front();
   }
 }
 
 bool Surface::use_surface_layer_ = false;
 
 }  // namespace exo