exo: Recreate Surface resources on context lost.

components/exo/buffer.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/buffer.h"
 
 #include <GLES2/gl2.h>
 #include <GLES2/gl2ext.h>
 #include <GLES2/gl2extchromium.h>
 #include <stdint.h>
@@ skipping 354 matching lines @@
       use_zero_copy_(use_zero_copy),
       is_overlay_candidate_(is_overlay_candidate),
       use_count_(0) {}
 
 Buffer::~Buffer() {}
 
 std::unique_ptr<cc::SingleReleaseCallback> Buffer::ProduceTextureMailbox(
     cc::TextureMailbox* texture_mailbox,
     bool secure_output_only,
     bool client_usage) {
-  // Non-client usage can only be allowed when the client is not allowed to
-  // use the buffer. If the buffer has been released to the client then it
-  // can no longer be used as the client might be writing to it.
-  if (!client_usage && !use_count_)
-    return nullptr;
-
+  DCHECK(attach_count_);
   DLOG_IF(WARNING, use_count_ && client_usage)
       << "Producing a texture mailbox for a buffer that has not been released";
 
   // Some clients think that they can reuse a buffer before it's released by
   // performing a fast blit into the buffer. This behavior is bad as it prevents
   // the client from knowing when the buffer is actually released (e.g. the
   // release notification for the previous use of buffer can arrive after the
   // buffer has been reused). We stop running the release callback when this
   // type of behavior is detected as having the buffer always be busy will
   // result in fewer drawing artifacts.
@@ skipping 66 matching lines @@
       gpu_memory_buffer_->GetSize(), gfx::GpuMemoryBufferId(),
       false /* is_overlay_candidate */, secure_output_only);
   // The mailbox texture will be released when no longer used by the
   // compositor.
   return cc::SingleReleaseCallback::Create(
       base::Bind(&Buffer::Texture::Release, base::Unretained(texture),
                  base::Bind(&Buffer::ReleaseTexture, AsWeakPtr(),
                             base::Passed(&texture_))));
 }
 
+void Buffer::OnAttach() {
+  DLOG_IF(WARNING, attach_count_ > 0u)
+      << "Reattaching a buffer that is already attached to another surface.";
+  attach_count_++;
+}
+
+void Buffer::OnDetach() {
+  DCHECK_GT(attach_count_, 0u);
+  --attach_count_;
+  CheckReleaseCallback();
+}
+
 gfx::Size Buffer::GetSize() const {
   return gpu_memory_buffer_->GetSize();
 }
 
 std::unique_ptr<base::trace_event::TracedValue> Buffer::AsTracedValue() const {
   std::unique_ptr<base::trace_event::TracedValue> value(
       new base::trace_event::TracedValue());
   gfx::Size size = gpu_memory_buffer_->GetSize();
   value->SetInteger("width", size.width());
   value->SetInteger("height", size.height());
   value->SetInteger("format",
                     static_cast<int>(gpu_memory_buffer_->GetFormat()));
   return value;
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // Buffer, private:
 
 void Buffer::Release() {
   DCHECK_GT(use_count_, 0u);
-  if (--use_count_)
+  --use_count_;
+  CheckReleaseCallback();
+}
+
+void Buffer::CheckReleaseCallback() {
+  if (attach_count_ || use_count_)
     return;
 
   // Run release callback to notify the client that buffer has been released.
   if (!release_callback_.is_null())
     release_callback_.Run();
 }
 
 void Buffer::ReleaseTexture(std::unique_ptr<Texture> texture) {
   texture_ = std::move(texture);
 }
 
 void Buffer::ReleaseContentsTexture(std::unique_ptr<Texture> texture) {
   TRACE_EVENT0("exo", "Buffer::ReleaseContentsTexture");
 
   contents_texture_ = std::move(texture);
   Release();
 }
 
 }  // namespace exo