Make ReflectorImpl use mailboxes

content/browser/compositor/reflector_impl.cc

 // Copyright 2014 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 "content/browser/compositor/reflector_impl.h"
 
 #include "base/bind.h"
 #include "base/location.h"
 #include "content/browser/compositor/browser_compositor_output_surface.h"
+#include "content/browser/compositor/owned_mailbox.h"
 #include "content/common/gpu/client/gl_helper.h"
 #include "ui/compositor/layer.h"
 
 namespace content {
 
 ReflectorImpl::ReflectorImpl(
     ui::Compositor* mirrored_compositor,
     ui::Layer* mirroring_layer,
     IDMap<BrowserCompositorOutputSurface>* output_surface_map,
     int surface_id)
-    : texture_id_(0),
-      texture_size_(mirrored_compositor->size()),
-      output_surface_map_(output_surface_map),
+    : output_surface_map_(output_surface_map),
+      output_surface_(NULL),
+      impl_thread_texture_id_(0),
+      needs_set_mailbox_(true),
       mirrored_compositor_(mirrored_compositor),
-      mirroring_compositor_(mirroring_layer->GetCompositor()),
       mirroring_layer_(mirroring_layer),
       impl_message_loop_(ui::Compositor::GetCompositorMessageLoop()),
       main_message_loop_(base::MessageLoopProxy::current()),
       surface_id_(surface_id) {
-  impl_message_loop_->PostTask(
-      FROM_HERE,
-      base::Bind(&ReflectorImpl::InitOnImplThread, this));
+  GLHelper* helper = ImageTransportFactory::GetInstance()->GetGLHelper();
+  main_thread_mailbox_ = new OwnedMailbox(helper);
+  impl_message_loop_->PostTask(FROM_HERE,
+                               base::Bind(&ReflectorImpl::InitOnImplThread,
+                                          this,
+                                          main_thread_mailbox_->holder()));
 }
 
-void ReflectorImpl::InitOnImplThread() {
+void ReflectorImpl::InitOnImplThread(const gpu::MailboxHolder& mailbox_holder) {
   // Ignore if the reflector was shutdown before
   // initialized, or it's already initialized.
   if (!output_surface_map_ || gl_helper_.get())
     return;
 
+  impl_thread_mailbox_holder_ = mailbox_holder;
+
   BrowserCompositorOutputSurface* source_surface =
       output_surface_map_->Lookup(surface_id_);
   // Skip if the source surface isn't ready yet. This will be
-  // initiailze when the source surface becomes ready.
+  // initialized when the source surface becomes ready.
   if (!source_surface)
     return;
 
-  AttachToOutputSurfaceOnImplThread(source_surface);
-  // The shared texture doesn't have the data, so invokes full redraw
-  // now.
-  main_message_loop_->PostTask(
-      FROM_HERE,
-      base::Bind(&ReflectorImpl::FullRedrawContentOnMainThread,
-                 scoped_refptr<ReflectorImpl>(this)));
+  AttachToOutputSurfaceOnImplThread(impl_thread_mailbox_holder_,
+                                    source_surface);
 }
 
-void ReflectorImpl::OnSourceSurfaceReady(int surface_id) {
-  DCHECK_EQ(surface_id_, surface_id);
-  InitOnImplThread();
+void ReflectorImpl::OnSourceSurfaceReady(
+    BrowserCompositorOutputSurface* source_surface) {
+  AttachToOutputSurfaceOnImplThread(impl_thread_mailbox_holder_,
+                                    source_surface);
 }
 
 void ReflectorImpl::Shutdown() {
-  mirroring_compositor_ = NULL;
+  main_thread_mailbox_ = NULL;
+  mirroring_layer_->SetShowPaintedContent();
   mirroring_layer_ = NULL;
-  {
-    base::AutoLock lock(texture_lock_);
-    texture_id_ = 0;
-  }
-  shared_texture_ = NULL;
   impl_message_loop_->PostTask(
       FROM_HERE,
       base::Bind(&ReflectorImpl::ShutdownOnImplThread, this));
 }
 
+void ReflectorImpl::DetachFromOutputSurface() {
+  DCHECK(output_surface_);
+  output_surface_->SetReflector(NULL);
+  DCHECK(impl_thread_texture_id_);
+  gl_helper_->DeleteTexture(impl_thread_texture_id_);
+  impl_thread_texture_id_ = 0;
+  gl_helper_.reset();
+  output_surface_ = NULL;
+}
+
 void ReflectorImpl::ShutdownOnImplThread() {
-  BrowserCompositorOutputSurface* output_surface =
-      output_surface_map_->Lookup(surface_id_);
-  if (output_surface)
-    output_surface->SetReflector(NULL);
+  if (output_surface_)
+    DetachFromOutputSurface();
   output_surface_map_ = NULL;
-  gl_helper_.reset();
   // The instance must be deleted on main thread.
   main_message_loop_->PostTask(
       FROM_HERE,
       base::Bind(&ReflectorImpl::DeleteOnMainThread,
                  scoped_refptr<ReflectorImpl>(this)));
 }
 
 void ReflectorImpl::ReattachToOutputSurfaceFromMainThread(
     BrowserCompositorOutputSurface* output_surface) {
+  GLHelper* helper = ImageTransportFactory::GetInstance()->GetGLHelper();
+  main_thread_mailbox_ = new OwnedMailbox(helper);
+  needs_set_mailbox_ = true;
   impl_message_loop_->PostTask(
       FROM_HERE,
       base::Bind(&ReflectorImpl::AttachToOutputSurfaceOnImplThread,
-                 this, output_surface));
+                 this,
+                 main_thread_mailbox_->holder(),
+                 output_surface));
 }
 
 void ReflectorImpl::OnMirroringCompositorResized() {
-  mirroring_compositor_->ScheduleFullRedraw();
+  mirroring_layer_->SchedulePaint(mirroring_layer_->bounds());
 }
 
-void ReflectorImpl::OnLostResources() {
-  mirroring_layer_->SetShowPaintedContent();
-}
-
-void ReflectorImpl::OnReshape(gfx::Size size) {
-  if (texture_size_ == size)
-    return;
-  texture_size_ = size;
-  {
-    base::AutoLock lock(texture_lock_);
-    if (texture_id_) {
-      gl_helper_->ResizeTexture(texture_id_, size);
-      gl_helper_->Flush();
-    }
+void ReflectorImpl::OnSwapBuffers() {
+  gfx::Size size = output_surface_->SurfaceSize();
+  if (impl_thread_texture_id_) {
+    gl_helper_->CopyTextureFullImage(impl_thread_texture_id_, size);
+    gl_helper_->Flush();
   }
   main_message_loop_->PostTask(
       FROM_HERE,
-      base::Bind(&ReflectorImpl::UpdateTextureSizeOnMainThread,
-                 this->AsWeakPtr(),
-                 texture_size_));
-}
-
-void ReflectorImpl::OnSwapBuffers() {
-  {
-    base::AutoLock lock(texture_lock_);
-    if (texture_id_) {
-      gl_helper_->CopyTextureFullImage(texture_id_, texture_size_);
-      gl_helper_->Flush();
-    }
-  }
-  main_message_loop_->PostTask(
-      FROM_HERE,
-      base::Bind(&ReflectorImpl::FullRedrawOnMainThread,
-                 this->AsWeakPtr(),
-                 texture_size_));
+      base::Bind(
+          &ReflectorImpl::FullRedrawOnMainThread, this->AsWeakPtr(), size));
 }
 
 void ReflectorImpl::OnPostSubBuffer(gfx::Rect rect) {
-  {
-    base::AutoLock lock(texture_lock_);
-    if (texture_id_) {
-      gl_helper_->CopyTextureSubImage(texture_id_, rect);
-      gl_helper_->Flush();
-    }
+  if (impl_thread_texture_id_) {
+    gl_helper_->CopyTextureSubImage(impl_thread_texture_id_, rect);
+    gl_helper_->Flush();
   }
   main_message_loop_->PostTask(
       FROM_HERE,
       base::Bind(&ReflectorImpl::UpdateSubBufferOnMainThread,
                  this->AsWeakPtr(),
-                 texture_size_,
+                 output_surface_->SurfaceSize(),
                  rect));
 }
 
-void ReflectorImpl::CreateSharedTextureOnMainThread(gfx::Size size) {
-  {
-    base::AutoLock lock(texture_lock_);
-    texture_id_ =
-        ImageTransportFactory::GetInstance()->GetGLHelper()->CreateTexture();
-    shared_texture_ =
-        ImageTransportFactory::GetInstance()->CreateOwnedTexture(
-            size, 1.0f, texture_id_);
-    ImageTransportFactory::GetInstance()->GetGLHelper()->Flush();
-  }
-  mirroring_layer_->SetExternalTexture(shared_texture_.get());
-  FullRedrawOnMainThread(size);
-}
-
 ReflectorImpl::~ReflectorImpl() {
   // Make sure the reflector is deleted on main thread.
   DCHECK_EQ(main_message_loop_.get(),
             base::MessageLoopProxy::current().get());
 }
 
+static void ReleaseMailbox(scoped_refptr<OwnedMailbox> mailbox,
+                           unsigned int sync_point,
+                           bool is_lost) {
+  mailbox->UpdateSyncPoint(sync_point);
+}
+
 void ReflectorImpl::AttachToOutputSurfaceOnImplThread(
+    const gpu::MailboxHolder& mailbox_holder,
     BrowserCompositorOutputSurface* output_surface) {
+  if (output_surface == output_surface_)
+    return;
+  if (output_surface_)
+    DetachFromOutputSurface();
+  output_surface_ = output_surface;
   output_surface->context_provider()->BindToCurrentThread();
   gl_helper_.reset(
       new GLHelper(output_surface->context_provider()->ContextGL(),
                    output_surface->context_provider()->ContextSupport()));
+  impl_thread_texture_id_ = gl_helper_->ConsumeMailboxToTexture(
+      mailbox_holder.mailbox, mailbox_holder.sync_point);
+  gl_helper_->ResizeTexture(impl_thread_texture_id_,
+                            output_surface->SurfaceSize());
+  gl_helper_->Flush();
   output_surface->SetReflector(this);
+  // The texture doesn't have the data, so invokes full redraw now.
   main_message_loop_->PostTask(
       FROM_HERE,
-      base::Bind(&ReflectorImpl::CreateSharedTextureOnMainThread,
-                 this->AsWeakPtr(),
-                 texture_size_));
+      base::Bind(&ReflectorImpl::FullRedrawContentOnMainThread,
+                 scoped_refptr<ReflectorImpl>(this)));
 }
 
 void ReflectorImpl::UpdateTextureSizeOnMainThread(gfx::Size size) {
-  if (!mirroring_layer_)
+  if (!mirroring_layer_ || !main_thread_mailbox_ ||
+      main_thread_mailbox_->mailbox().IsZero())

[danakj, 2014/04/08 16:08:01]

I'm not sure where this method is all called, but if the mailbox is empty (say
it failed in ReflectorImpl::ReattachToOutputSurfaceFromMainThread) should we be
SetShowPaintedContent somewhere?

[piman, 2014/04/08 23:17:46]

It can't fail in ReattachToOutputSurfaceFromMainThread (GenMailbox doesn't fail
any more), the only case where the mailbox is NULL is after a Shutdown, when we
already do SetShowPaintedContent.

The main case for the IsZero check is because OwnedTexture clears its mailbox
when the context is lost - that's the desired behavior. In that case, we don't
want to do anything until we recreate the output surface anyway (giving a new
mailbox in ReattachToOutputSurfaceFromMainThread). The compositor won't draw,
etc.

I added a SetShowPaintedContent in ReattachToOutputSurfaceFromMainThread so that
we release the old mailbox as early as possible in all cases (timing between
ReattachToOutputSurfaceFromMainThread and the OnLostResources is fundamentally
racy, no clear way around that).

     return;
+  if (needs_set_mailbox_) {
+    mirroring_layer_->SetTextureMailbox(
+        cc::TextureMailbox(main_thread_mailbox_->holder()),
+        cc::SingleReleaseCallback::Create(
+            base::Bind(ReleaseMailbox, main_thread_mailbox_)),
+        size);
+    needs_set_mailbox_ = false;
+  } else if (size != texture_size_) {

[danakj, 2014/04/08 16:08:01]

This texture_size_ is only here to prevent extra calls to SetTextureSize()?
Would it make sense to have ui::Layer early out instead, if this is even a
problem?

[piman, 2014/04/08 23:17:46]

I wanted to avoid full layer invalidations if the size doesn't change, caused by
either SetTextureSize or SetBounds.

SetBounds already catches redundant sizes, so I moved the check in
SetTextureSize to save the field here.

+    mirroring_layer_->SetTextureSize(size);
+  } else {
+    return;
+  }
   mirroring_layer_->SetBounds(gfx::Rect(size));
+  texture_size_ = size;
 }
 
 void ReflectorImpl::FullRedrawOnMainThread(gfx::Size size) {
-  if (!mirroring_compositor_)
+  if (!mirroring_layer_)
     return;
   UpdateTextureSizeOnMainThread(size);
-  mirroring_compositor_->ScheduleFullRedraw();
+  mirroring_layer_->SchedulePaint(mirroring_layer_->bounds());
 }
 
 void ReflectorImpl::UpdateSubBufferOnMainThread(gfx::Size size,
                                                 gfx::Rect rect) {
-  if (!mirroring_compositor_)
+  if (!mirroring_layer_)
     return;
   UpdateTextureSizeOnMainThread(size);
   // Flip the coordinates to compositor's one.
   int y = size.height() - rect.y() - rect.height();
   gfx::Rect new_rect(rect.x(), y, rect.width(), rect.height());
   mirroring_layer_->SchedulePaint(new_rect);
 }
 
 void ReflectorImpl::FullRedrawContentOnMainThread() {
   mirrored_compositor_->ScheduleFullRedraw();
 }
 
 }  // namespace content