exo: Recreate Surface resources on context lost.

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 188 matching lines @@
   window_->SetProperty(kSurfaceKey, this);
   window_->Init(ui::LAYER_SOLID_COLOR);
   window_->set_layer_owner_delegate(this);
   window_->SetEventTargeter(base::WrapUnique(new CustomWindowTargeter));
   window_->set_owned_by_parent(false);
   factory_owner_->surface_ = this;
   factory_owner_->id_allocator_ =
       aura::Env::GetInstance()->context_factory()->CreateSurfaceIdAllocator();
   factory_owner_->surface_factory_.reset(
       new cc::SurfaceFactory(surface_manager_, factory_owner_.get()));
+  aura::Env::GetInstance()->context_factory()->AddObserver(this);
 }
 
 Surface::~Surface() {
+  aura::Env::GetInstance()->context_factory()->RemoveObserver(this);
   FOR_EACH_OBSERVER(SurfaceObserver, observers_, OnSurfaceDestroying(this));
 
   window_->layer()->SetShowSolidColorContent();
 
   factory_owner_->surface_ = nullptr;
 
   // Call pending frame callbacks with a null frame time to indicate that they
   // have been cancelled.
   frame_callbacks_.splice(frame_callbacks_.end(), pending_frame_callbacks_);
   active_frame_callbacks_.splice(active_frame_callbacks_.end(),
                                  frame_callbacks_);
   for (const auto& frame_callback : active_frame_callbacks_)
     frame_callback.Run(base::TimeTicks());
 
   if (!surface_id_.is_null())
     factory_owner_->surface_factory_->Destroy(surface_id_);
 }
 
 // static
 Surface* Surface::AsSurface(const aura::Window* window) {
   return window->GetProperty(kSurfaceKey);
 }
 
 void Surface::Attach(Buffer* buffer) {
   TRACE_EVENT1("exo", "Surface::Attach", "buffer",
                buffer ? buffer->GetSize().ToString() : "null");
 
   has_pending_contents_ = true;
-  pending_buffer_ = buffer ? buffer->AsWeakPtr() : base::WeakPtr<Buffer>();
+  pending_buffer_.Reset(buffer ? buffer->AsWeakPtr() : base::WeakPtr<Buffer>());
 }
 
 void Surface::Damage(const gfx::Rect& damage) {
   TRACE_EVENT1("exo", "Surface::Damage", "damage", damage.ToString());
 
   pending_damage_.op(gfx::RectToSkIRect(damage), SkRegion::kUnion_Op);
 }
 
 void Surface::RequestFrameCallback(const FrameCallback& callback) {
   TRACE_EVENT0("exo", "Surface::RequestFrameCallback");
@@ skipping 151 matching lines @@
 
 void Surface::Commit() {
   TRACE_EVENT0("exo", "Surface::Commit");
 
   needs_commit_surface_hierarchy_ = true;
 
   if (state_ != pending_state_)
     has_pending_layer_changes_ = true;
 
   if (has_pending_contents_) {
-    if (pending_buffer_ &&
-        (current_resource_.size != pending_buffer_->GetSize())) {
+    if (pending_buffer_.buffer() &&
+        (current_resource_.size != pending_buffer_.buffer()->GetSize())) {
       has_pending_layer_changes_ = true;
-    } else if (!pending_buffer_ && !current_resource_.size.IsEmpty()) {
+    } else if (!pending_buffer_.buffer() && !current_resource_.size.IsEmpty()) {
       has_pending_layer_changes_ = true;
     }
   }
 
   if (delegate_) {
     delegate_->OnSurfaceCommit();
   } else {
     CheckIfSurfaceHierarchyNeedsCommitToNewSurfaces();
     CommitSurfaceHierarchy();
   }
 }
 
+void Surface::OnLostResources() {
+  if (surface_id_.is_null())
+    return;
+
+  UpdateResource(false);
+  UpdateSurface(false);
+}
+
 void Surface::CommitSurfaceHierarchy() {
   DCHECK(needs_commit_surface_hierarchy_);
   needs_commit_surface_hierarchy_ = false;
   has_pending_layer_changes_ = false;
 
   state_ = pending_state_;
   pending_state_.only_visible_on_secure_output = false;
 
   // We update contents if Attach() has been called since last commit.
-  // TODO(jbauman): Support producing a new texture mailbox after lost
-  // context.
   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;
+    current_buffer_ = std::move(pending_buffer_);
 
-      cc::TextureMailbox texture_mailbox;
-      texture_mailbox_release_callback = current_buffer_->ProduceTextureMailbox(
-          &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();
-    }
+    UpdateResource(true);
   }
 
   cc::SurfaceId old_surface_id = 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 / state_.buffer_scale));
-
-  gfx::Size layer_size;  // Size of the output layer, in DIP.
-  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(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 (!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 = 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 = 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 =
-        state_.blend_mode == SkXfermode::kSrc_Mode ||
-        state_.opaque_region.contains(gfx::RectToSkIRect(quad_rect));
-    if (frame_is_opaque) {
-      opaque_rect = quad_rect;
-    } 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, 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());
+  UpdateSurface(true);
 
   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);
   }
 
-  content_size_ = layer_size;
-
   if (old_surface_id != surface_id_) {
+    float contents_surface_to_layer_scale = 1.0;
     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);
+        content_size_, contents_surface_to_layer_scale, content_size_);
     window_->layer()->SetBounds(
-        gfx::Rect(window_->layer()->bounds().origin(), layer_size));
-    window_->layer()->SetFillsBoundsOpaquely(state_.alpha == 1.0f &&
-                                             frame_is_opaque);
+        gfx::Rect(window_->layer()->bounds().origin(), content_size_));
+    window_->layer()->SetFillsBoundsOpaquely(
+        state_.alpha == 1.0f &&
+
+        state_.opaque_region.contains(
+            gfx::RectToSkIRect(gfx::Rect(content_size_))));
   }
 
   // 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(),
@@ skipping 95 matching lines @@
   std::unique_ptr<base::trace_event::TracedValue> value(
       new base::trace_event::TracedValue());
   value->SetString("name", window_->layer()->name());
   return value;
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // ui::LayerOwnerDelegate overrides:
 
 void Surface::OnLayerRecreated(ui::Layer* old_layer, ui::Layer* new_layer) {
-  if (!current_buffer_)
+  if (!current_buffer_.buffer())
     return;
 
   // TODO(reveman): Give the client a chance to provide new contents.
   SetSurfaceLayerContents(new_layer);
 }
 
 void Surface::WillDraw(cc::SurfaceId id) {
   while (!active_frame_callbacks_.empty()) {
     active_frame_callbacks_.front().Run(base::TimeTicks::Now());
     active_frame_callbacks_.pop_front();
@@ skipping 10 matching lines @@
 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);
 }
 
+Surface::BufferAttachment::BufferAttachment() {}
+
+Surface::BufferAttachment::~BufferAttachment() {
+  if (buffer_)
+    buffer_->OnDetach();
+}
+
+Surface::BufferAttachment& Surface::BufferAttachment::operator=(
+    BufferAttachment&& other) {
+  if (buffer_)
+    buffer_->OnDetach();
+  buffer_ = other.buffer_;
+  other.buffer_ = base::WeakPtr<Buffer>();
+  return *this;
+}
+
+base::WeakPtr<Buffer>& Surface::BufferAttachment::buffer() {
+  return buffer_;
+}
+
+const base::WeakPtr<Buffer>& Surface::BufferAttachment::buffer() const {
+  return buffer_;
+}
+
+void Surface::BufferAttachment::Reset(base::WeakPtr<Buffer> buffer) {
+  if (buffer)
+    buffer->OnAttach();
+  if (buffer_)
+    buffer_->OnDetach();
+  buffer_ = buffer;
+}
+
 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;
 }
@@ skipping 12 matching lines @@
   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);
 }
 
+void Surface::UpdateResource(bool client_usage) {
+  std::unique_ptr<cc::SingleReleaseCallback> texture_mailbox_release_callback;
+
+  cc::TextureMailbox texture_mailbox;
+  if (current_buffer_.buffer()) {
+    texture_mailbox_release_callback =
+        current_buffer_.buffer()->ProduceTextureMailbox(
+            &texture_mailbox, state_.only_visible_on_secure_output,
+            client_usage);
+  }
+
+  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();
+
+    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();
+  }
+}
+
+void Surface::UpdateSurface(bool full_damage) {
+  gfx::Size buffer_size = current_resource_.size;
+  gfx::SizeF scaled_buffer_size(
+      gfx::ScaleSize(gfx::SizeF(buffer_size), 1.0f / state_.buffer_scale));
+
+  gfx::Size layer_size;  // Size of the output layer, in DIP.
+  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(state_.crop.size());
+  } else {
+    layer_size = gfx::ToCeiledSize(scaled_buffer_size);
+  }
+
+  content_size_ = layer_size;
+  // TODO(jbauman): Figure out how this interacts with the pixel size of
+  // CopyOutputRequests on the layer.
+  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 (!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 = 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 = full_damage
+                              ? gfx::Rect(contents_surface_size)
+                              : 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 = state_.alpha;
+
+  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;
+    if (state_.blend_mode == SkXfermode::kSrc_Mode ||
+        state_.opaque_region.contains(gfx::RectToSkIRect(quad_rect))) {
+      opaque_rect = quad_rect;
+    } 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, 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);
+  }
+
+  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());
+}
+
 int64_t Surface::SetPropertyInternal(const void* key,
                                      const char* name,
                                      PropertyDeallocator deallocator,
                                      int64_t value,
                                      int64_t default_value) {
   int64_t old = GetPropertyInternal(key, default_value);
   if (value == default_value) {
     prop_map_.erase(key);
   } else {
     Value prop_value;
     prop_value.name = name;
     prop_value.value = value;
     prop_value.deallocator = deallocator;
     prop_map_[key] = prop_value;
   }
   return old;
 }
 
 int64_t Surface::GetPropertyInternal(const void* key,
                                      int64_t default_value) const {
   std::map<const void*, Value>::const_iterator iter = prop_map_.find(key);
   if (iter == prop_map_.end())
     return default_value;
   return iter->second.value;
 }
 
 }  // namespace exo