exo: Only create new SurfaceLayer if layer properties change.

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 171 matching lines @@
 
 void SurfaceFactoryOwner::SetBeginFrameSource(
     cc::BeginFrameSource* begin_frame_source) {}
 
 ////////////////////////////////////////////////////////////////////////////////
 // Surface, public:
 
 Surface::Surface()
     : window_(new 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) {
   window_->SetType(ui::wm::WINDOW_TYPE_CONTROL);
   window_->SetName("ExoSurface");
   window_->SetProperty(kSurfaceKey, this);
   window_->Init(ui::LAYER_SOLID_COLOR);
   window_->set_layer_owner_delegate(this);
   window_->SetEventTargeter(base::WrapUnique(new CustomWindowTargeter));
@@ skipping 66 matching lines @@
 void Surface::RequestFrameCallback(const FrameCallback& callback) {
   TRACE_EVENT0("exo", "Surface::RequestFrameCallback");
 
   pending_frame_callbacks_.push_back(callback);
 }
 
 void Surface::SetOpaqueRegion(const SkRegion& region) {
   TRACE_EVENT1("exo", "Surface::SetOpaqueRegion", "region",
                gfx::SkIRectToRect(region.getBounds()).ToString());
 
-  pending_opaque_region_ = region;
+  pending_state_.opaque_region = region;
 }
 
 void Surface::SetInputRegion(const SkRegion& region) {
   TRACE_EVENT1("exo", "Surface::SetInputRegion", "region",
                gfx::SkIRectToRect(region.getBounds()).ToString());
 
-  pending_input_region_ = region;
+  pending_state_.input_region = region;
 }
 
 void Surface::SetBufferScale(float scale) {
   TRACE_EVENT1("exo", "Surface::SetBufferScale", "scale", scale);
 
-  pending_buffer_scale_ = scale;
+  pending_state_.buffer_scale = scale;
 }
 
 void Surface::AddSubSurface(Surface* sub_surface) {
   TRACE_EVENT1("exo", "Surface::AddSubSurface", "sub_surface",
                sub_surface->AsTracedValue());
 
   DCHECK(!sub_surface->window()->parent());
   DCHECK(!sub_surface->window()->IsVisible());
   window_->AddChild(sub_surface->window());
 
   DCHECK(!ListContainsEntry(pending_sub_surfaces_, sub_surface));
   pending_sub_surfaces_.push_back(std::make_pair(sub_surface, gfx::Point()));
+  has_pending_layer_changes_ = true;
 }
 
 void Surface::RemoveSubSurface(Surface* sub_surface) {
   TRACE_EVENT1("exo", "Surface::AddSubSurface", "sub_surface",
                sub_surface->AsTracedValue());
 
   window_->RemoveChild(sub_surface->window());
   if (sub_surface->window()->IsVisible())
     sub_surface->window()->Hide();
 
   DCHECK(ListContainsEntry(pending_sub_surfaces_, sub_surface));
   pending_sub_surfaces_.erase(
       FindListEntry(pending_sub_surfaces_, sub_surface));
+  has_pending_layer_changes_ = true;
 }
 
 void Surface::SetSubSurfacePosition(Surface* sub_surface,
                                     const gfx::Point& position) {
   TRACE_EVENT2("exo", "Surface::SetSubSurfacePosition", "sub_surface",
                sub_surface->AsTracedValue(), "position", position.ToString());
 
   auto it = FindListEntry(pending_sub_surfaces_, sub_surface);
   DCHECK(it != pending_sub_surfaces_.end());
+  if (it->second == position)
+    return;
   it->second = position;
+  has_pending_layer_changes_ = true;
 }
 
 void Surface::PlaceSubSurfaceAbove(Surface* sub_surface, Surface* reference) {
   TRACE_EVENT2("exo", "Surface::PlaceSubSurfaceAbove", "sub_surface",
                sub_surface->AsTracedValue(), "reference",
                reference->AsTracedValue());
 
   if (sub_surface == reference) {
     DLOG(WARNING) << "Client tried to place sub-surface above itself";
     return;
   }
 
   auto position_it = pending_sub_surfaces_.begin();
   if (reference != this) {
     position_it = FindListEntry(pending_sub_surfaces_, reference);
     if (position_it == pending_sub_surfaces_.end()) {
       DLOG(WARNING) << "Client tried to place sub-surface above a reference "
                        "surface that is neither a parent nor a sibling";
       return;
     }
 
     // Advance iterator to have |position_it| point to the sibling surface
     // above |reference|.
     ++position_it;
   }
 
   DCHECK(ListContainsEntry(pending_sub_surfaces_, sub_surface));
-  pending_sub_surfaces_.splice(
-      position_it, pending_sub_surfaces_,
-      FindListEntry(pending_sub_surfaces_, sub_surface));
+  auto it = FindListEntry(pending_sub_surfaces_, sub_surface);
+  if (it == position_it)
+    return;
+  pending_sub_surfaces_.splice(position_it, pending_sub_surfaces_, it);
+  has_pending_layer_changes_ = true;
 }
 
 void Surface::PlaceSubSurfaceBelow(Surface* sub_surface, Surface* sibling) {
   TRACE_EVENT2("exo", "Surface::PlaceSubSurfaceBelow", "sub_surface",
                sub_surface->AsTracedValue(), "sibling",
                sibling->AsTracedValue());
 
   if (sub_surface == sibling) {
     DLOG(WARNING) << "Client tried to place sub-surface below itself";
     return;
   }
 
   auto sibling_it = FindListEntry(pending_sub_surfaces_, sibling);
   if (sibling_it == pending_sub_surfaces_.end()) {
     DLOG(WARNING) << "Client tried to place sub-surface below a surface that "
                      "is not a sibling";
     return;
   }
 
   DCHECK(ListContainsEntry(pending_sub_surfaces_, sub_surface));
-  pending_sub_surfaces_.splice(
-      sibling_it, pending_sub_surfaces_,
-      FindListEntry(pending_sub_surfaces_, sub_surface));
+  auto it = FindListEntry(pending_sub_surfaces_, sub_surface);
+  if (it == sibling_it)
+    return;
+  pending_sub_surfaces_.splice(sibling_it, pending_sub_surfaces_, it);
+  has_pending_layer_changes_ = true;
 }
 
 void Surface::SetViewport(const gfx::Size& viewport) {
   TRACE_EVENT1("exo", "Surface::SetViewport", "viewport", viewport.ToString());
 
-  pending_viewport_ = viewport;
+  pending_state_.viewport = viewport;
 }
 
 void Surface::SetCrop(const gfx::RectF& crop) {
   TRACE_EVENT1("exo", "Surface::SetCrop", "crop", crop.ToString());
 
-  pending_crop_ = crop;
+  pending_state_.crop = crop;
 }
 
 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;
+  pending_state_.only_visible_on_secure_output = only_visible_on_secure_output;
 }
 
 void Surface::SetBlendMode(SkXfermode::Mode blend_mode) {
   TRACE_EVENT1("exo", "Surface::SetBlendMode", "blend_mode", blend_mode);
 
-  pending_blend_mode_ = blend_mode;
+  pending_state_.blend_mode = blend_mode;
 }
 
 void Surface::SetAlpha(float alpha) {
   TRACE_EVENT1("exo", "Surface::SetAlpha", "alpha", alpha);
 
-  pending_alpha_ = alpha;
+  pending_state_.alpha = alpha;
 }
 
 void Surface::Commit() {
   TRACE_EVENT0("exo", "Surface::Commit");
 
   needs_commit_surface_hierarchy_ = true;
 
-  if (delegate_)
+  if (state_ != pending_state_)
+    has_pending_layer_changes_ = true;
+
+  if (has_pending_contents_) {
+    if (pending_buffer_ &&
+        (current_resource_.size != pending_buffer_->GetSize())) {
+      has_pending_layer_changes_ = true;
+    } else if (!pending_buffer_ && !current_resource_.size.IsEmpty()) {
+      has_pending_layer_changes_ = true;
+    }
+  }
+
+  if (delegate_) {
     delegate_->OnSurfaceCommit();
-  else
+  } else {
+    CheckIfSurfaceHierarchyNeedsCommitToNewSurfaces();
     CommitSurfaceHierarchy();
+  }
 }
 
 void Surface::CommitSurfaceHierarchy() {
   DCHECK(needs_commit_surface_hierarchy_);
   needs_commit_surface_hierarchy_ = false;
+  has_pending_layer_changes_ = 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_;
+  state_ = pending_state_;
+  pending_state_.only_visible_on_secure_output = false;
 
   if (factory_owner_) {
     CommitSurfaceContents();
   } else {
     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_) {
     Surface* sub_surface = sub_surface_entry.first;
 
     // Synchronsouly commit all pending state of the sub-surface and its
     // decendents.
     if (sub_surface->needs_commit_surface_hierarchy())
@@ skipping 16 matching lines @@
     sub_surface->window()->SetBounds(gfx::Rect(
         sub_surface_entry.second, sub_surface->window()->layer()->size()));
   }
 }
 
 bool Surface::IsSynchronized() const {
   return delegate_ ? delegate_->IsSurfaceSynchronized() : false;
 }
 
 gfx::Rect Surface::GetHitTestBounds() const {
-  SkIRect bounds = input_region_.getBounds();
+  SkIRect bounds = state_.input_region.getBounds();
   if (!bounds.intersect(
           gfx::RectToSkIRect(gfx::Rect(window_->layer()->size()))))
     return gfx::Rect();
   return gfx::SkIRectToRect(bounds);
 }
 
 bool Surface::HitTestRect(const gfx::Rect& rect) const {
   if (HasHitTestMask())
-    return input_region_.intersects(gfx::RectToSkIRect(rect));
+    return state_.input_region.intersects(gfx::RectToSkIRect(rect));
 
   return rect.Intersects(gfx::Rect(window_->layer()->size()));
 }
 
 bool Surface::HasHitTestMask() const {
-  return !input_region_.contains(
+  return !state_.input_region.contains(
       gfx::RectToSkIRect(gfx::Rect(window_->layer()->size())));
 }
 
 void Surface::GetHitTestMask(gfx::Path* mask) const {
-  input_region_.getBoundaryPath(mask);
+  state_.input_region.getBoundaryPath(mask);
 }
 
 void Surface::RegisterCursorProvider(Pointer* provider) {
   cursor_providers_.insert(provider);
 }
 
 void Surface::UnregisterCursorProvider(Pointer* provider) {
   cursor_providers_.erase(provider);
 }
 
@@ skipping 109 matching lines @@
   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::CheckIfSurfaceHierarchyNeedsCommitToNewSurfaces() {
+  if (HasLayerHierarchyChanged())
+    SetSurfaceHierarchyNeedsCommitToNewSurfaces();
+}
+
+Surface::State::State() : input_region(SkIRect::MakeLargest()) {}
+
+Surface::State::~State() = default;
+
+bool Surface::State::operator==(const State& other) {
+  return (other.crop == crop && alpha == other.alpha &&
+          other.blend_mode == blend_mode && other.viewport == viewport &&
+          other.opaque_region == opaque_region &&
+          other.buffer_scale == buffer_scale &&
+          other.input_region == input_region);
+}
+
+bool Surface::HasLayerHierarchyChanged() const {
+  if (needs_commit_surface_hierarchy_ && has_pending_layer_changes_)
+    return true;
+
+  for (const auto& sub_surface_entry : pending_sub_surfaces_) {
+    if (sub_surface_entry.first->HasLayerHierarchyChanged())
+      return true;
+  }
+  return false;
+}
+
+void Surface::SetSurfaceHierarchyNeedsCommitToNewSurfaces() {
+  needs_commit_to_new_surface_ = true;
+  for (auto& sub_surface_entry : pending_sub_surfaces_) {
+    sub_surface_entry.first->SetSurfaceHierarchyNeedsCommitToNewSurfaces();
+  }
+}
+
 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();
 
     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, only_visible_on_secure_output_,
+          &texture_mailbox, state_.only_visible_on_secure_output,
           true /* 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_);
+          texture_mailbox.size_in_pixels(), 1.0f / state_.buffer_scale);
       window_->layer()->SetTextureMailbox(
           texture_mailbox, std::move(texture_mailbox_release_callback),
           texture_size_in_dip_);
       window_->layer()->SetTextureFlipped(false);
     } else {
       // Show solid color content if no buffer is attached or we failed
       // to produce a texture mailbox for the currently attached buffer.
       window_->layer()->SetShowSolidColorContent();
       window_->layer()->SetColor(SK_ColorBLACK);
     }
 
     // Schedule redraw of the damage region.
     for (SkRegion::Iterator it(pending_damage_); !it.done(); it.next())
       window_->layer()->SchedulePaint(gfx::SkIRectToRect(it.rect()));
 
     // Reset damage.
     pending_damage_.setEmpty();
   }
 
   if (window_->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 (!crop_.IsEmpty()) {
-      DLOG_IF(WARNING, !gfx::IsExpressibleAsInt(crop_.width()) ||
-                           !gfx::IsExpressibleAsInt(crop_.height()))
-          << "Crop rectangle size (" << crop_.size().ToString()
+    if (!state_.viewport.IsEmpty()) {
+      contents_size = state_.viewport;
+    } else if (!state_.crop.IsEmpty()) {
+      DLOG_IF(WARNING, !gfx::IsExpressibleAsInt(state_.crop.width()) ||
+                           !gfx::IsExpressibleAsInt(state_.crop.height()))
+          << "Crop rectangle size (" << state_.crop.size().ToString()
           << ") most be expressible using integers when viewport is not set";
-      contents_size = gfx::ToCeiledSize(crop_.size());
+      contents_size = gfx::ToCeiledSize(state_.crop.size());
     }
-    window_->layer()->SetTextureCrop(crop_);
+    window_->layer()->SetTextureCrop(state_.crop);
     window_->layer()->SetTextureScale(
         static_cast<float>(texture_size_in_dip_.width()) /
             contents_size.width(),
         static_cast<float>(texture_size_in_dip_.height()) /
             contents_size.height());
-    window_->layer()->SetTextureAlpha(alpha_);
+    window_->layer()->SetTextureAlpha(state_.alpha);
     window_->layer()->SetBounds(
         gfx::Rect(window_->layer()->bounds().origin(), contents_size));
   }
 
   // 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.
   window_->layer()->SetFillsBoundsOpaquely(
-      pending_blend_mode_ == SkXfermode::kSrc_Mode ||
-      pending_opaque_region_.contains(
+      state_.blend_mode == SkXfermode::kSrc_Mode ||
+      state_.opaque_region.contains(
           gfx::RectToSkIRect(gfx::Rect(window_->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();
 
     if (current_buffer_) {
       std::unique_ptr<cc::SingleReleaseCallback>
           texture_mailbox_release_callback;
 
       cc::TextureMailbox texture_mailbox;
       texture_mailbox_release_callback = current_buffer_->ProduceTextureMailbox(
-          &texture_mailbox, only_visible_on_secure_output_,
+          &texture_mailbox, state_.only_visible_on_secure_output,
           true /* client_usage */);
       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();
     }
   }
 
   cc::SurfaceId old_surface_id = surface_id_;
-  surface_id_ = factory_owner_->id_allocator_->GenerateId();
-  factory_owner_->surface_factory_->Create(surface_id_);
+  if (needs_commit_to_new_surface_ || surface_id_.is_null()) {
+    needs_commit_to_new_surface_ = false;
+    surface_id_ = factory_owner_->id_allocator_->GenerateId();
+    factory_owner_->surface_factory_->Create(surface_id_);
+  }
 
   gfx::Size buffer_size = current_resource_.size;
   gfx::SizeF scaled_buffer_size(
-      gfx::ScaleSize(gfx::SizeF(buffer_size), 1.0f / pending_buffer_scale_));
+      gfx::ScaleSize(gfx::SizeF(buffer_size), 1.0f / state_.buffer_scale));
 
   gfx::Size layer_size;  // Size of the output layer, in DIP.
-  if (!pending_viewport_.IsEmpty()) {
-    layer_size = pending_viewport_;
-  } else if (!crop_.IsEmpty()) {
-    DLOG_IF(WARNING, !gfx::IsExpressibleAsInt(crop_.width()) ||
-                         !gfx::IsExpressibleAsInt(crop_.height()))
-        << "Crop rectangle size (" << crop_.size().ToString()
+  if (!state_.viewport.IsEmpty()) {
+    layer_size = state_.viewport;
+  } else if (!state_.crop.IsEmpty()) {
+    DLOG_IF(WARNING, !gfx::IsExpressibleAsInt(state_.crop.width()) ||
+                         !gfx::IsExpressibleAsInt(state_.crop.height()))
+        << "Crop rectangle size (" << state_.crop.size().ToString()
         << ") most be expressible using integers when viewport is not set";
-    layer_size = gfx::ToCeiledSize(crop_.size());
+    layer_size = gfx::ToCeiledSize(state_.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 (!crop_.IsEmpty()) {
-    uv_top_left = crop_.origin();
+  if (!state_.crop.IsEmpty()) {
+    uv_top_left = state_.crop.origin();
 
     uv_top_left.Scale(1.f / scaled_buffer_size.width(),
                       1.f / scaled_buffer_size.height());
-    uv_bottom_right = crop_.bottom_right();
+    uv_bottom_right = state_.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 = alpha_;
+  quad_state->opacity = state_.alpha;
 
   bool frame_is_opaque = false;
 
   std::unique_ptr<cc::DelegatedFrameData> delegated_frame(
       new cc::DelegatedFrameData);
   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));
+        state_.blend_mode == SkXfermode::kSrc_Mode ||
+        state_.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());
+    } else if (state_.opaque_region.isRect()) {
+      opaque_rect = gfx::SkIRectToRect(state_.opaque_region.getBounds());
     }
 
     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, only_visible_on_secure_output_);
+                         false, false, state_.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);
   frame->delegated_frame_data = std::move(delegated_frame);
 
   factory_owner_->surface_factory_->SubmitCompositorFrame(
       surface_id_, std::move(frame), cc::SurfaceFactory::DrawCallback());
 
-  if (!old_surface_id.is_null()) {
+  if (!old_surface_id.is_null() && old_surface_id != surface_id_) {
     factory_owner_->surface_factory_->SetPreviousFrameSurface(surface_id_,
                                                               old_surface_id);
     factory_owner_->surface_factory_->Destroy(old_surface_id);
   }
 
-  window_->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);
-  window_->layer()->SetBounds(
-      gfx::Rect(window_->layer()->bounds().origin(), layer_size));
-  window_->layer()->SetFillsBoundsOpaquely(alpha_ == 1.0f && frame_is_opaque);
+  if (old_surface_id != surface_id_) {
+    window_->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);
+    window_->layer()->SetBounds(
+        gfx::Rect(window_->layer()->bounds().origin(), layer_size));
+    window_->layer()->SetFillsBoundsOpaquely(state_.alpha == 1.0f &&
+                                             frame_is_opaque);
+  }
 
   // Reset damage.
   pending_damage_.setEmpty();
 
   DCHECK(!current_resource_.id ||
          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::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_,
-                                             false /* client_usage */);
+      current_buffer_->ProduceTextureMailbox(
+          &texture_mailbox, state_.only_visible_on_secure_output,
+          false /* 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->SetTextureCrop(state_.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_);
+  layer->SetTextureAlpha(state_.alpha);
 }
 
 void Surface::SetSurfaceLayerContents(ui::Layer* layer) {
   if (surface_id_.is_null())
     return;
 
   gfx::Size layer_size = layer->bounds().size();
   float contents_surface_to_layer_scale = 1.0f;
 
   layer->SetShowSurface(
       surface_id_,
       base::Bind(&SatisfyCallback, base::Unretained(surface_manager_)),
       base::Bind(&RequireCallback, base::Unretained(surface_manager_)),
       layer_size, contents_surface_to_layer_scale, layer_size);
 }
 
 bool Surface::use_surface_layer_ = false;
 
 }  // namespace exo