exo: Handle lost context situations 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 "base/callback_helpers.h"
 #include "base/logging.h"
 #include "base/trace_event/trace_event.h"
 #include "base/trace_event/trace_event_argument.h"
@@ skipping 23 matching lines @@
 bool ListContainsEntry(T& list, U key) {
   return FindListEntry(list, key) != list.end();
 }
 
 }  // namespace
 
 ////////////////////////////////////////////////////////////////////////////////
 // Surface, public:
 
 Surface::Surface()
-    : needs_commit_surface_hierarchy_(false),
-      has_contents_(false),
+    : has_pending_contents_(false),
+      needs_commit_surface_hierarchy_(false),
+      update_contents_after_successful_compositing_(false),
       compositor_(nullptr),
       delegate_(nullptr) {
   SetLayer(new ui::Layer(ui::LAYER_SOLID_COLOR));
   set_owned_by_client();
   SetVisible(false);
   SetEnabled(false);
 }
 
 Surface::~Surface() {
   FOR_EACH_OBSERVER(SurfaceObserver, observers_, OnSurfaceDestroying(this));
 
   layer()->SetShowSolidColorContent();
 
   if (compositor_)
     compositor_->RemoveObserver(this);
 
   // 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());
 }
 
 void Surface::Attach(Buffer* buffer) {
   TRACE_EVENT1("exo", "Surface::Attach", "buffer", buffer->AsTracedValue());
 
+  has_pending_contents_ = true;
   pending_buffer_ = buffer ? buffer->AsWeakPtr() : base::WeakPtr<Buffer>();
   PreferredSizeChanged();
 }
 
 void Surface::Damage(const gfx::Rect& damage) {
   TRACE_EVENT1("exo", "Surface::Damage", "damage", damage.ToString());
 
   pending_damage_.Union(damage);
 }
 
@@ skipping 106 matching lines @@
   if (delegate_)
     delegate_->OnSurfaceCommit();
   else
     CommitSurfaceHierarchy();
 }
 
 void Surface::CommitSurfaceHierarchy() {
   DCHECK(needs_commit_surface_hierarchy_);
   needs_commit_surface_hierarchy_ = false;
 
-  cc::TextureMailbox texture_mailbox;
-  scoped_ptr<cc::SingleReleaseCallback> texture_mailbox_release_callback;
-  if (pending_buffer_) {
-    texture_mailbox_release_callback =
-        pending_buffer_->AcquireTextureMailbox(&texture_mailbox);
+  // 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();
-    has_contents_ = true;
-  } else {
-    // Show solid color content if there is no pending buffer.
-    layer()->SetShowSolidColorContent();
-    has_contents_ = false;
+
+    cc::TextureMailbox texture_mailbox;
+    scoped_ptr<cc::SingleReleaseCallback> texture_mailbox_release_callback;
+    if (current_buffer_) {
+      texture_mailbox_release_callback =
+          current_buffer_->ProduceTextureMailbox(&texture_mailbox);
+    }
+
+    if (texture_mailbox_release_callback) {
+      // Update layer with the new contents.
+      layer()->SetTextureMailbox(texture_mailbox,
+                                 texture_mailbox_release_callback.Pass(),
+                                 texture_mailbox.size_in_pixels());
+      layer()->SetTextureFlipped(false);
+      layer()->SetBounds(gfx::Rect(layer()->bounds().origin(),
+                                   texture_mailbox.size_in_pixels()));
+      layer()->SetFillsBoundsOpaquely(pending_opaque_region_.contains(
+          gfx::RectToSkIRect(gfx::Rect(texture_mailbox.size_in_pixels()))));
+    } else {
+      // Show solid color content if no buffer is attached or we failed
+      // to produce a texture mailbox for the currently attached buffer.
+      layer()->SetShowSolidColorContent();
+      layer()->SetColor(SK_ColorBLACK);
+    }
+
+    // Schedule redraw of the damage region.
+    layer()->SchedulePaint(pending_damage_);
+    pending_damage_ = gfx::Rect();
   }
 
-  if (texture_mailbox_release_callback) {
-    // Update layer with the new contents.
-    layer()->SetTextureMailbox(texture_mailbox,
-                               texture_mailbox_release_callback.Pass(),
-                               texture_mailbox.size_in_pixels());
-    layer()->SetTextureFlipped(false);
-    layer()->SetBounds(gfx::Rect(layer()->bounds().origin(),
-                                 texture_mailbox.size_in_pixels()));
-    layer()->SetFillsBoundsOpaquely(pending_opaque_region_.contains(
-        gfx::RectToSkIRect(gfx::Rect(texture_mailbox.size_in_pixels()))));
-  }
-
-  // Schedule redraw of the damage region.
-  layer()->SchedulePaint(pending_damage_);
-  pending_damage_ = gfx::Rect();
-
   ui::Compositor* compositor = layer()->GetCompositor();
   if (compositor && !pending_frame_callbacks_.empty()) {
     // Start observing the compositor for frame callbacks.
     if (!compositor_) {
       compositor->AddObserver(this);
       compositor_ = compositor;
     }
 
     // Move pending frame callbacks to the end of |frame_callbacks_|.
     frame_callbacks_.splice(frame_callbacks_.end(), pending_frame_callbacks_);
@@ skipping 76 matching lines @@
 
 void Surface::OnCompositingStarted(ui::Compositor* compositor,
                                    base::TimeTicks start_time) {
   // Run all frame callbacks associated with the compositor's active tree.
   while (!active_frame_callbacks_.empty()) {
     active_frame_callbacks_.front().Run(start_time);
     active_frame_callbacks_.pop_front();
   }
 }
 
+void Surface::OnCompositingEnded(ui::Compositor* compositor) {
+  // Nothing 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;
+
+  // Update contents by producing a new texture mailbox for the current buffer.
+  cc::TextureMailbox texture_mailbox;
+  scoped_ptr<cc::SingleReleaseCallback> texture_mailbox_release_callback =
+      current_buffer_->ProduceTextureMailbox(&texture_mailbox);
+  if (texture_mailbox_release_callback) {
+    layer()->SetTextureMailbox(texture_mailbox,
+                               texture_mailbox_release_callback.Pass(),
+                               texture_mailbox.size_in_pixels());
+    layer()->SetTextureFlipped(false);
+    layer()->SchedulePaint(gfx::Rect(texture_mailbox.size_in_pixels()));
+  }
+}
+
+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;
 }
 
 }  // namespace exo