Use gpu::Mailbox in IPCs instead of std::string

content/renderer/browser_plugin/browser_plugin_compositing_helper.cc

 // Copyright (c) 2013 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/renderer/browser_plugin/browser_plugin_compositing_helper.h"
 
 #include "cc/context_provider.h"
 #include "cc/solid_color_layer.h"
 #include "cc/texture_layer.h"
 #include "content/common/browser_plugin/browser_plugin_messages.h"
@@ skipping 44 matching lines @@
 }
 
 // If we have a mailbox that was freed up from the compositor,
 // but we are not expected to return it to the guest renderer
 // via an ACK, we should free it because we now own it.
 // To free the mailbox memory, we need a context to consume it
 // into a texture ID and then delete this texture ID.
 // We use a shared graphics context accessible from the main
 // thread to do it.
 void BrowserPluginCompositingHelper::FreeMailboxMemory(
-    const std::string& mailbox_name,
+    const gpu::Mailbox& mailbox_name,
     unsigned sync_point) {
-  if (mailbox_name.empty())
+  if (mailbox_name.IsZero())
     return;
 
   scoped_refptr<cc::ContextProvider> context_provider =
       RenderThreadImpl::current()->OffscreenContextProviderForMainThread();
   if (!context_provider->InitializeOnMainThread())
     return;
   if (!context_provider->BindToCurrentThread())
     return;
 
   WebKit::WebGraphicsContext3D *context = context_provider->Context3d();
   // When a buffer is released from the compositor, we also get a
   // sync point that specifies when in the command buffer
   // it's safe to use it again.
   // If the sync point is non-zero, we need to tell our context
   // to wait until this sync point is reached before we can safely
   // delete the buffer.
   if (sync_point)
     context->waitSyncPoint(sync_point);
 
   unsigned texture_id = context->createTexture();
   context->bindTexture(GL_TEXTURE_2D, texture_id);
-  context->consumeTextureCHROMIUM(
-      GL_TEXTURE_2D,
-      reinterpret_cast<const int8*>(mailbox_name.data()));
+  context->consumeTextureCHROMIUM( GL_TEXTURE_2D, mailbox_name.name);

[alexst (slow to review), 2013/03/06 21:54:27]

There is an extra space here
                       
consumeTextureCHROMIUM( GL_TEXTURE_2D
                       ^

[piman, 2013/03/07 01:48:02]

Done.

   context->deleteTexture(texture_id);
 }
 
 void BrowserPluginCompositingHelper::MailboxReleased(
-    const std::string& mailbox_name,
+    const gpu::Mailbox& mailbox_name,
     int gpu_route_id,
     int gpu_host_id,
     unsigned sync_point) {
   // This means the GPU process crashed and we have nothing further to do.
   // Nobody is expecting an ACK and the buffer doesn't need to be deleted
   // because it went away with the GPU process.
   if (last_gpu_host_id_ != gpu_host_id)
     return;
 
   // This means the guest crashed.
@@ skipping 41 matching lines @@
     container_->setWebLayer(NULL);
   container_ = NULL;
 
   texture_layer_ = NULL;
   background_layer_ = NULL;
   web_layer_.reset();
 }
 
 void BrowserPluginCompositingHelper::OnBuffersSwapped(
     const gfx::Size& size,
-    const std::string& mailbox_name,
+    const gpu::Mailbox& mailbox_name,
     int gpu_route_id,
     int gpu_host_id,
     float device_scale_factor) {
   // If the guest crashed but the GPU process didn't, we may still have
   // a transport surface waiting on an ACK, which we must send to
   // avoid leaking.
   if (last_gpu_route_id_ != gpu_route_id && last_gpu_host_id_ == gpu_host_id)
     ack_pending_for_crashed_guest_ = ack_pending_;
 
   // If these mismatch, we are either just starting up, GPU process crashed or
@@ skipping 26 matching lines @@
   if (buffer_size_ != size) {
     buffer_size_ = size;
     // The container size is in DIP, so is the layer size.
     // Buffer size is in physical pixels, so we need to adjust
     // it by the device scale factor.
     gfx::Size device_scale_adjusted_size = gfx::ToFlooredSize(
         gfx::ScaleSize(buffer_size_, 1.0f / device_scale_factor));
     texture_layer_->setBounds(device_scale_adjusted_size);
   }
 
-  bool current_mailbox_valid = !mailbox_name.empty();
+  bool current_mailbox_valid = !mailbox_name.IsZero();
   if (!last_mailbox_valid_) {
-    MailboxReleased(std::string(), gpu_route_id, gpu_host_id, 0);
+    MailboxReleased(gpu::Mailbox(), gpu_route_id, gpu_host_id, 0);
     if (!current_mailbox_valid)
       return;
   }
 
   cc::TextureMailbox::ReleaseCallback callback;
   if (current_mailbox_valid) {
     callback = base::Bind(&BrowserPluginCompositingHelper::MailboxReleased,
                           scoped_refptr<BrowserPluginCompositingHelper>(this),
                           mailbox_name,
                           gpu_route_id,
                           gpu_host_id);
   }
   texture_layer_->setTextureMailbox(cc::TextureMailbox(mailbox_name,
                                                        callback));
   last_mailbox_valid_ = current_mailbox_valid;
 }
 
 void BrowserPluginCompositingHelper::UpdateVisibility(bool visible) {
   if (texture_layer_)
     texture_layer_->setIsDrawable(visible);
 }
 
 }  // namespace content