exo: Release context provider references when main thread context is 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 73 matching lines @@
   gles2->GenMailboxCHROMIUM(mailbox->name);
   gles2->ProduceTextureCHROMIUM(target, mailbox->name);
 }
 
 }  // namespace
 
 ////////////////////////////////////////////////////////////////////////////////
 // Buffer::Texture
 
 // Encapsulates the state and logic needed to bind a buffer to a GLES2 texture.
-class Buffer::Texture {
+class Buffer::Texture : public ui::ContextFactoryObserver {
  public:
-  explicit Texture(cc::ContextProvider* context_provider);
-  Texture(cc::ContextProvider* context_provider,
+  Texture(ui::ContextFactory* context_factory,
+          cc::ContextProvider* context_provider);
+  Texture(ui::ContextFactory* context_factory,
+          cc::ContextProvider* context_provider,
           gfx::GpuMemoryBuffer* gpu_memory_buffer,
           unsigned texture_target,
           unsigned query_type);
-  ~Texture();
+  ~Texture() override;
+
+  // Overridden from ui::ContextFactoryObserver:
+  void OnLostResources() override;
 
   // Returns true if GLES2 resources for texture have been lost.
   bool IsLost();
 
   // Allow texture to be reused after |sync_token| has passed and runs
   // |callback|.
   void Release(const base::Closure& callback,
                const gpu::SyncToken& sync_token,
                bool is_lost);
 
@@ skipping 11 matching lines @@
   // Copy the contents of texture to |destination| and runs |callback| when
   // completed. Returns a sync token that can be used when accessing texture
   // from a different context.
   gpu::SyncToken CopyTexImage(Texture* destination,
                               const base::Closure& callback);
 
   // Returns the mailbox for this texture.
   gpu::Mailbox mailbox() const { return mailbox_; }
 
  private:
+  void DestroyResources();
   void ReleaseWhenQueryResultIsAvailable(const base::Closure& callback);
   void Released();
   void ScheduleWaitForRelease(base::TimeDelta delay);
   void WaitForRelease();
 
+  ui::ContextFactory* context_factory_;
   scoped_refptr<cc::ContextProvider> context_provider_;
   const unsigned texture_target_;
   const unsigned query_type_;
   const GLenum internalformat_;
   unsigned image_id_ = 0;
   unsigned query_id_ = 0;
   unsigned texture_id_ = 0;
   gpu::Mailbox mailbox_;
   base::Closure release_callback_;
   base::TimeTicks wait_for_release_time_;
   bool wait_for_release_pending_ = false;
   base::WeakPtrFactory<Texture> weak_ptr_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(Texture);
 };
 
-Buffer::Texture::Texture(cc::ContextProvider* context_provider)
-    : context_provider_(context_provider),
+Buffer::Texture::Texture(ui::ContextFactory* context_factory,
+                         cc::ContextProvider* context_provider)
+    : context_factory_(context_factory),
+      context_provider_(context_provider),
       texture_target_(GL_TEXTURE_2D),
       query_type_(GL_COMMANDS_COMPLETED_CHROMIUM),
       internalformat_(GL_RGBA),
       weak_ptr_factory_(this) {
   gpu::gles2::GLES2Interface* gles2 = context_provider_->ContextGL();
   texture_id_ = CreateGLTexture(gles2, texture_target_);
   // Generate a crypto-secure random mailbox name.
   CreateGLTextureMailbox(gles2, texture_id_, texture_target_, &mailbox_);
+  // Provides a notification when |context_provider_| is lost.
+  context_factory_->AddObserver(this);
 }
 
-Buffer::Texture::Texture(cc::ContextProvider* context_provider,
+Buffer::Texture::Texture(ui::ContextFactory* context_factory,
+                         cc::ContextProvider* context_provider,
                          gfx::GpuMemoryBuffer* gpu_memory_buffer,
                          unsigned texture_target,
                          unsigned query_type)
-    : context_provider_(context_provider),
+    : context_factory_(context_factory),
+      context_provider_(context_provider),
       texture_target_(texture_target),
       query_type_(query_type),
       internalformat_(GLInternalFormat(gpu_memory_buffer->GetFormat())),
       weak_ptr_factory_(this) {
   gpu::gles2::GLES2Interface* gles2 = context_provider_->ContextGL();
   gfx::Size size = gpu_memory_buffer->GetSize();
   image_id_ =
       gles2->CreateImageCHROMIUM(gpu_memory_buffer->AsClientBuffer(),
                                  size.width(), size.height(), internalformat_);
   DLOG_IF(WARNING, !image_id_) << "Failed to create GLImage";
 
   gles2->GenQueriesEXT(1, &query_id_);
   texture_id_ = CreateGLTexture(gles2, texture_target_);
+  // Provides a notification when |context_provider_| is lost.
+  context_factory_->AddObserver(this);
 }
 
 Buffer::Texture::~Texture() {
-  gpu::gles2::GLES2Interface* gles2 = context_provider_->ContextGL();
-  gles2->DeleteTextures(1, &texture_id_);
-  if (query_id_)
-    gles2->DeleteQueriesEXT(1, &query_id_);
-  if (image_id_)
-    gles2->DestroyImageCHROMIUM(image_id_);
+  DestroyResources();
+  context_factory_->RemoveObserver(this);
+}
+
+void Buffer::Texture::OnLostResources() {
+  DestroyResources();
+  context_provider_ = nullptr;
 }
 
 bool Buffer::Texture::IsLost() {
-  gpu::gles2::GLES2Interface* gles2 = context_provider_->ContextGL();
-  return gles2->GetGraphicsResetStatusKHR() != GL_NO_ERROR;
+  if (context_provider_) {
+    gpu::gles2::GLES2Interface* gles2 = context_provider_->ContextGL();
+    return gles2->GetGraphicsResetStatusKHR() != GL_NO_ERROR;
+  }
+  return true;
 }
 
 void Buffer::Texture::Release(const base::Closure& callback,
                               const gpu::SyncToken& sync_token,
                               bool is_lost) {
-  gpu::gles2::GLES2Interface* gles2 = context_provider_->ContextGL();
-  if (sync_token.HasData())
-    gles2->WaitSyncTokenCHROMIUM(sync_token.GetConstData());
+  if (context_provider_) {
+    gpu::gles2::GLES2Interface* gles2 = context_provider_->ContextGL();
+    if (sync_token.HasData())
+      gles2->WaitSyncTokenCHROMIUM(sync_token.GetConstData());
+  }
 
   // Run callback as texture can be reused immediately after waiting for sync
   // token.
   callback.Run();
 }
 
 gpu::SyncToken Buffer::Texture::BindTexImage() {
-  gpu::gles2::GLES2Interface* gles2 = context_provider_->ContextGL();
-  gles2->ActiveTexture(GL_TEXTURE0);
-  gles2->BindTexture(texture_target_, texture_id_);
-  DCHECK_NE(image_id_, 0u);
-  gles2->BindTexImage2DCHROMIUM(texture_target_, image_id_);
-  // Generate a crypto-secure random mailbox name if not already done.
-  if (mailbox_.IsZero())
-    CreateGLTextureMailbox(gles2, texture_id_, texture_target_, &mailbox_);
-  // Create and return a sync token that can be used to ensure that the
-  // BindTexImage2DCHROMIUM call is processed before issuing any commands
-  // that will read from the texture on a different context.
-  uint64_t fence_sync = gles2->InsertFenceSyncCHROMIUM();
-  gles2->OrderingBarrierCHROMIUM();
   gpu::SyncToken sync_token;
-  gles2->GenUnverifiedSyncTokenCHROMIUM(fence_sync, sync_token.GetData());
+  if (context_provider_) {
+    gpu::gles2::GLES2Interface* gles2 = context_provider_->ContextGL();
+    gles2->ActiveTexture(GL_TEXTURE0);
+    gles2->BindTexture(texture_target_, texture_id_);
+    DCHECK_NE(image_id_, 0u);
+    gles2->BindTexImage2DCHROMIUM(texture_target_, image_id_);
+    // Generate a crypto-secure random mailbox name if not already done.
+    if (mailbox_.IsZero())
+      CreateGLTextureMailbox(gles2, texture_id_, texture_target_, &mailbox_);
+    // Create and return a sync token that can be used to ensure that the
+    // BindTexImage2DCHROMIUM call is processed before issuing any commands
+    // that will read from the texture on a different context.
+    uint64_t fence_sync = gles2->InsertFenceSyncCHROMIUM();
+    gles2->OrderingBarrierCHROMIUM();
+    gles2->GenUnverifiedSyncTokenCHROMIUM(fence_sync, sync_token.GetData());
+  }
   return sync_token;
 }
 
 void Buffer::Texture::ReleaseTexImage(const base::Closure& callback,
                                       const gpu::SyncToken& sync_token,
                                       bool is_lost) {
-  gpu::gles2::GLES2Interface* gles2 = context_provider_->ContextGL();
-  if (sync_token.HasData())
-    gles2->WaitSyncTokenCHROMIUM(sync_token.GetConstData());
-  gles2->ActiveTexture(GL_TEXTURE0);
-  gles2->BindTexture(texture_target_, texture_id_);
-  DCHECK_NE(query_id_, 0u);
-  gles2->BeginQueryEXT(query_type_, query_id_);
-  gles2->ReleaseTexImage2DCHROMIUM(texture_target_, image_id_);
-  gles2->EndQueryEXT(query_type_);
-  // Run callback when query result is available and ReleaseTexImage has been
-  // handled if sync token has data and buffer has been used. If buffer was
-  // never used then run the callback immediately.
-  if (sync_token.HasData()) {
-    ReleaseWhenQueryResultIsAvailable(callback);
-  } else {
-    callback.Run();
+  if (context_provider_) {
+    gpu::gles2::GLES2Interface* gles2 = context_provider_->ContextGL();
+    if (sync_token.HasData())
+      gles2->WaitSyncTokenCHROMIUM(sync_token.GetConstData());
+    gles2->ActiveTexture(GL_TEXTURE0);
+    gles2->BindTexture(texture_target_, texture_id_);
+    DCHECK_NE(query_id_, 0u);
+    gles2->BeginQueryEXT(query_type_, query_id_);
+    gles2->ReleaseTexImage2DCHROMIUM(texture_target_, image_id_);
+    gles2->EndQueryEXT(query_type_);
+    // Run callback when query result is available and ReleaseTexImage has been
+    // handled if sync token has data and buffer has been used. If buffer was
+    // never used then run the callback immediately.
+    if (sync_token.HasData()) {
+      ReleaseWhenQueryResultIsAvailable(callback);
+      return;
+    }
   }
+  callback.Run();
 }
 
 gpu::SyncToken Buffer::Texture::CopyTexImage(Texture* destination,
                                              const base::Closure& callback) {
-  gpu::gles2::GLES2Interface* gles2 = context_provider_->ContextGL();
-  gles2->ActiveTexture(GL_TEXTURE0);
-  gles2->BindTexture(texture_target_, texture_id_);
-  DCHECK_NE(image_id_, 0u);
-  gles2->BindTexImage2DCHROMIUM(texture_target_, image_id_);
-  gles2->CopyTextureCHROMIUM(texture_id_, destination->texture_id_,
-                             internalformat_, GL_UNSIGNED_BYTE, false, false,
-                             false);
-  DCHECK_NE(query_id_, 0u);
-  gles2->BeginQueryEXT(query_type_, query_id_);
-  gles2->ReleaseTexImage2DCHROMIUM(texture_target_, image_id_);
-  gles2->EndQueryEXT(query_type_);
-  // Run callback when query result is available and ReleaseTexImage has been
-  // handled.
-  ReleaseWhenQueryResultIsAvailable(callback);
-  // Create and return a sync token that can be used to ensure that the
-  // CopyTextureCHROMIUM call is processed before issuing any commands
-  // that will read from the target texture on a different context.
-  uint64_t fence_sync = gles2->InsertFenceSyncCHROMIUM();
-  gles2->OrderingBarrierCHROMIUM();
   gpu::SyncToken sync_token;
-  gles2->GenUnverifiedSyncTokenCHROMIUM(fence_sync, sync_token.GetData());
+  if (context_provider_) {
+    gpu::gles2::GLES2Interface* gles2 = context_provider_->ContextGL();
+    gles2->ActiveTexture(GL_TEXTURE0);
+    gles2->BindTexture(texture_target_, texture_id_);
+    DCHECK_NE(image_id_, 0u);
+    gles2->BindTexImage2DCHROMIUM(texture_target_, image_id_);
+    gles2->CopyTextureCHROMIUM(texture_id_, destination->texture_id_,
+                               internalformat_, GL_UNSIGNED_BYTE, false, false,
+                               false);
+    DCHECK_NE(query_id_, 0u);
+    gles2->BeginQueryEXT(query_type_, query_id_);
+    gles2->ReleaseTexImage2DCHROMIUM(texture_target_, image_id_);
+    gles2->EndQueryEXT(query_type_);
+    // Run callback when query result is available and ReleaseTexImage has been
+    // handled.
+    ReleaseWhenQueryResultIsAvailable(callback);
+    // Create and return a sync token that can be used to ensure that the
+    // CopyTextureCHROMIUM call is processed before issuing any commands
+    // that will read from the target texture on a different context.
+    uint64_t fence_sync = gles2->InsertFenceSyncCHROMIUM();
+    gles2->OrderingBarrierCHROMIUM();
+    gles2->GenUnverifiedSyncTokenCHROMIUM(fence_sync, sync_token.GetData());
+  }
   return sync_token;
 }
 
+void Buffer::Texture::DestroyResources() {
+  if (context_provider_) {
+    gpu::gles2::GLES2Interface* gles2 = context_provider_->ContextGL();
+    gles2->DeleteTextures(1, &texture_id_);
+    if (query_id_)
+      gles2->DeleteQueriesEXT(1, &query_id_);
+    if (image_id_)
+      gles2->DestroyImageCHROMIUM(image_id_);
+  }
+}
+
 void Buffer::Texture::ReleaseWhenQueryResultIsAvailable(
     const base::Closure& callback) {
+  DCHECK(context_provider_);
   DCHECK(release_callback_.is_null());
   release_callback_ = callback;
   base::TimeDelta wait_for_release_delay =
       base::TimeDelta::FromMilliseconds(kWaitForReleaseDelayMs);
   wait_for_release_time_ = base::TimeTicks::Now() + wait_for_release_delay;
   ScheduleWaitForRelease(wait_for_release_delay);
   context_provider_->ContextSupport()->SignalQuery(
       query_id_,
       base::Bind(&Buffer::Texture::Released, weak_ptr_factory_.GetWeakPtr()));
 }
@@ skipping 22 matching lines @@
     return;
 
   base::TimeTicks current_time = base::TimeTicks::Now();
   if (current_time < wait_for_release_time_) {
     ScheduleWaitForRelease(wait_for_release_time_ - current_time);
     return;
   }
 
   base::Closure callback = base::ResetAndReturn(&release_callback_);
 
-  {
+  if (context_provider_) {
     TRACE_EVENT0("exo", "Buffer::Texture::WaitForQueryResult");
 
     // We need to wait for the result to be available. Getting the result of
     // the query implies waiting for it to become available. The actual result
     // is unimportant and also not well defined.
     unsigned result = 0;
     gpu::gles2::GLES2Interface* gles2 = context_provider_->ContextGL();
     gles2->GetQueryObjectuivEXT(query_id_, GL_QUERY_RESULT_EXT, &result);
   }
 
@@ skipping 43 matching lines @@
 
   // Increment the use count for this buffer.
   ++use_count_;
 
   // If textures are lost, destroy them to ensure that we create new ones below.
   if (contents_texture_ && contents_texture_->IsLost())
     contents_texture_.reset();
   if (texture_ && texture_->IsLost())
     texture_.reset();
 
+  ui::ContextFactory* context_factory =
+      aura::Env::GetInstance()->context_factory();
   // Note: This can fail if GPU acceleration has been disabled.
   scoped_refptr<cc::ContextProvider> context_provider =
-      aura::Env::GetInstance()
-          ->context_factory()
-          ->SharedMainThreadContextProvider();
+      context_factory->SharedMainThreadContextProvider();
   if (!context_provider) {
     DLOG(WARNING) << "Failed to acquire a context provider";
     Release();  // Decrements the use count
     return nullptr;
   }
 
   // Create a new image texture for |gpu_memory_buffer_| with |texture_target_|
   // if one doesn't already exist. The contents of this buffer are copied to
   // |texture| using a call to CopyTexImage.
   if (!contents_texture_) {
     contents_texture_ = base::WrapUnique(
-        new Texture(context_provider.get(), gpu_memory_buffer_.get(),
-                    texture_target_, query_type_));
+        new Texture(context_factory, context_provider.get(),
+                    gpu_memory_buffer_.get(), texture_target_, query_type_));
   }
 
   if (use_zero_copy_) {
     // Zero-copy means using the contents texture directly.
     Texture* texture = contents_texture_.get();
 
     // This binds the latest contents of this buffer to |texture|.
     gpu::SyncToken sync_token = texture->BindTexImage();
 
     *texture_mailbox =
         cc::TextureMailbox(texture->mailbox(), sync_token, texture_target_,
                            gpu_memory_buffer_->GetSize(), is_overlay_candidate_,
                            secure_output_only);
     // The contents texture will be released when no longer used by the
     // compositor.
     return cc::SingleReleaseCallback::Create(
         base::Bind(&Buffer::Texture::ReleaseTexImage, base::Unretained(texture),
                    base::Bind(&Buffer::ReleaseContentsTexture, AsWeakPtr(),
                               base::Passed(&contents_texture_))));
   }
 
   // Create a mailbox texture that we copy the buffer contents to.
-  if (!texture_)
-    texture_ = base::WrapUnique(new Texture(context_provider.get()));
+  if (!texture_) {
+    texture_ =
+        base::WrapUnique(new Texture(context_factory, context_provider.get()));
+  }
 
   // Copy the contents of |contents_texture| to |texture| and produce a
   // texture mailbox from the result in |texture|.
   Texture* contents_texture = contents_texture_.get();
   Texture* texture = texture_.get();
 
   // The contents texture will be released when copy has completed.
   gpu::SyncToken sync_token = contents_texture->CopyTexImage(
       texture, base::Bind(&Buffer::ReleaseContentsTexture, AsWeakPtr(),
                           base::Passed(&contents_texture_)));
@@ skipping 59 matching lines @@
 }
 
 void Buffer::ReleaseContentsTexture(std::unique_ptr<Texture> texture) {
   TRACE_EVENT0("exo", "Buffer::ReleaseContentsTexture");
 
   contents_texture_ = std::move(texture);
   Release();
 }
 
 }  // namespace exo