Move Pepper to using mailboxes

webkit/plugins/ppapi/ppapi_plugin_instance.cc

 // Copyright (c) 2012 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 "webkit/plugins/ppapi/ppapi_plugin_instance.h"
 
 #include "base/bind.h"
 #include "base/callback_helpers.h"
 #include "base/debug/trace_event.h"
 #include "base/logging.h"
@@ skipping 555 matching lines @@
       container_->scrollRect(dx, dy, rect);
     } else {
       // Can't do optimized scrolling since there could be other elements on top
       // of us or the view renders via the accelerated compositor which is
       // incompatible with the move and backfill scrolling model.
       InvalidateRect(rect);
     }
   }
 }
 
-unsigned PluginInstance::GetBackingTextureId() {
-  if (bound_graphics_3d_.get())
-    return bound_graphics_3d_->GetBackingTextureId();
-
-  return 0;
-}
-
 void PluginInstance::CommitBackingTexture() {
   if (texture_layer_.get())
     texture_layer_->SetNeedsDisplay();
 }
 
 void PluginInstance::InstanceCrashed() {
   // Force free all resources and vars.
   HostGlobals::Get()->InstanceCrashed(pp_instance());
 
   // Free any associated graphics.
@@ skipping 983 matching lines @@
   bool is_mouselock_pending = TrackedCallback::IsPending(lock_mouse_callback_);
 
   if (flash_fullscreen == flash_fullscreen_) {
     // Manually clear callback when fullscreen fails with mouselock pending.
     if (!flash_fullscreen && is_mouselock_pending)
       lock_mouse_callback_->Run(PP_ERROR_FAILED);
     return;
   }
 
   PPB_Graphics3D_Impl* graphics_3d  = bound_graphics_3d_.get();
-  if (graphics_3d) {
-    if (flash_fullscreen) {
-      fullscreen_container_->ReparentContext(graphics_3d->platform_context());
-    } else {
-      delegate_->ReparentContext(graphics_3d->platform_context());
-    }
+  if (graphics_3d)
     UpdateLayer();
-  }
 
   bool old_plugin_focus = PluginHasFocus();
   flash_fullscreen_ = flash_fullscreen;
   if (is_mouselock_pending && !delegate()->IsMouseLocked(this)) {
     if (!IsProcessingUserGesture() &&
         !module_->permissions().HasPermission(
             ::ppapi::PERMISSION_BYPASS_USER_GESTURE)) {
       lock_mouse_callback_->Run(PP_ERROR_NO_USER_GESTURE);
     } else {
       // Open a user gesture here so the Webkit user gesture checks will succeed
@@ skipping 68 matching lines @@
   if (!frame)
     return false;
   WebView* view = frame->view();
   if (!view)
     return false;
 
   return view->isAcceleratedCompositingActive();
 }
 
 PluginDelegate::PlatformContext3D* PluginInstance::CreateContext3D() {
-  if (fullscreen_container_)
-    return fullscreen_container_->CreateContext3D();
-  else
-    return delegate_->CreateContext3D();
+  return delegate_->CreateContext3D();
 }
 
 bool PluginInstance::PrintPDFOutput(PP_Resource print_output,
                                     WebKit::WebCanvas* canvas) {
 #if defined(ENABLE_PRINTING)
   ::ppapi::thunk::EnterResourceNoLock<PPB_Buffer_API> enter(print_output, true);
   if (enter.failed())
     return false;
 
   BufferAutoMapper mapper(enter.object());
@@ skipping 78 matching lines @@
   return ret;
 #else  // defined(ENABLE_PRINTING)
   return false;
 #endif
 }
 
 PluginDelegate::PlatformGraphics2D* PluginInstance::GetBoundGraphics2D() const {
   return bound_graphics_2d_platform_;
 }
 
+static void IgnoreCallback(unsigned, bool) {}
+
 void PluginInstance::UpdateLayer() {
   if (!container_)
     return;
 
-  bool want_layer = GetBackingTextureId();
+  gpu::Mailbox mailbox;
+  if (bound_graphics_3d_) {
+    PluginDelegate::PlatformContext3D* context =
+        bound_graphics_3d_->platform_context();
+    context->GetBackingMailbox(&mailbox);
+  }
+  bool want_layer = !mailbox.IsZero();
 
   if (want_layer == !!texture_layer_.get() &&
       layer_bound_to_fullscreen_ == !!fullscreen_container_)
     return;
 
   if (texture_layer_.get()) {
-    texture_layer_->ClearClient();
     if (!layer_bound_to_fullscreen_)
       container_->setWebLayer(NULL);
     else if (fullscreen_container_)
       fullscreen_container_->SetLayer(NULL);
     web_layer_.reset();
     texture_layer_ = NULL;
   }
   if (want_layer) {
     DCHECK(bound_graphics_3d_.get());
-    texture_layer_ = cc::TextureLayer::Create(this);
+    texture_layer_ = cc::TextureLayer::CreateForMailbox(NULL);
     web_layer_.reset(new webkit::WebLayerImpl(texture_layer_));
     if (fullscreen_container_) {
       fullscreen_container_->SetLayer(web_layer_.get());
       // Ignore transparency in fullscreen, since that's what Flash always
       // wants to do, and that lets it not recreate a context if
       // wmode=transparent was specified.
       texture_layer_->SetContentsOpaque(true);
     } else {
       container_->setWebLayer(web_layer_.get());
       texture_layer_->SetContentsOpaque(bound_graphics_3d_->IsOpaque());
     }
+    texture_layer_->SetTextureMailbox(
+        cc::TextureMailbox(mailbox, base::Bind(&IgnoreCallback), 0));
   }
   layer_bound_to_fullscreen_ = !!fullscreen_container_;
 }
 
 void PluginInstance::AddPluginObject(PluginObject* plugin_object) {
   DCHECK(live_plugin_objects_.find(plugin_object) ==
          live_plugin_objects_.end());
   live_plugin_objects_.insert(plugin_object);
 }
 
@@ skipping 344 matching lines @@
                                   const PP_DecryptedFrameInfo* frame_info) {
   content_decryptor_delegate_->DeliverFrame(decrypted_frame, frame_info);
 }
 
 void PluginInstance::DeliverSamples(PP_Instance instance,
                                     PP_Resource audio_frames,
                                     const PP_DecryptedBlockInfo* block_info) {
   content_decryptor_delegate_->DeliverSamples(audio_frames, block_info);
 }
 
-unsigned PluginInstance::PrepareTexture(cc::ResourceUpdateQueue* queue) {
-  return GetBackingTextureId();
-}
-
-WebKit::WebGraphicsContext3D* PluginInstance::Context3d() {
-  DCHECK(bound_graphics_3d_.get());
-  DCHECK(bound_graphics_3d_->platform_context());
-  return bound_graphics_3d_->platform_context()->GetParentContext();
-}
-
-bool PluginInstance::PrepareTextureMailbox(cc::TextureMailbox* mailbox) {
-  return false;
-}
-
 void PluginInstance::NumberOfFindResultsChanged(PP_Instance instance,
                                                 int32_t total,
                                                 PP_Bool final_result) {
   DCHECK_NE(find_identifier_, -1);
   delegate_->NumberOfFindResultsChanged(find_identifier_, total,
                                         PP_ToBool(final_result));
 }
 
 void PluginInstance::SelectedFindResultChanged(PP_Instance instance,
                                                int32_t index) {
@@ skipping 408 matching lines @@
   screen_size_for_fullscreen_ = gfx::Size();
   WebElement element = container_->element();
   element.setAttribute(WebString::fromUTF8(kWidth), width_before_fullscreen_);
   element.setAttribute(WebString::fromUTF8(kHeight), height_before_fullscreen_);
   element.setAttribute(WebString::fromUTF8(kBorder), border_before_fullscreen_);
   element.setAttribute(WebString::fromUTF8(kStyle), style_before_fullscreen_);
 }
 
 }  // namespace ppapi
 }  // namespace webkit