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

content/browser/renderer_host/render_widget_host_view_aura.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 "content/browser/renderer_host/render_widget_host_view_aura.h"
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/command_line.h"
 #include "base/debug/trace_event.h"
@@ skipping 270 matching lines @@
     int32 route_id,
     int renderer_host_id,
     const gpu::Mailbox& received_mailbox,
     const gfx::Size& received_size,
     bool skip_frame,
     const scoped_refptr<ui::Texture>& texture_to_produce) {
   cc::CompositorFrameAck ack;
   ack.gl_frame_data.reset(new cc::GLFrameData());
   DCHECK(!texture_to_produce || !skip_frame);
   if (texture_to_produce) {
-    std::string mailbox_name = texture_to_produce->Produce();
-    std::copy(mailbox_name.data(),
-              mailbox_name.data() + mailbox_name.length(),
-              reinterpret_cast<char*>(ack.gl_frame_data->mailbox.name));
+    ack.gl_frame_data->mailbox = texture_to_produce->Produce();
     ack.gl_frame_data->size = texture_to_produce->size();
     ack.gl_frame_data->sync_point =
         content::ImageTransportFactory::GetInstance()->InsertSyncPoint();
   } else if (skip_frame) {
     // Skip the frame, i.e. tell the producer to reuse the same buffer that
     // we just received.
     ack.gl_frame_data->size = received_size;
     ack.gl_frame_data->mailbox = received_mailbox;
   }
 
   RenderWidgetHostImpl::SendSwapCompositorFrameAck(
       route_id, renderer_host_id, ack);
 }
 
 void AcknowledgeBufferForGpu(
     int32 route_id,
     int gpu_host_id,
-    const std::string& received_mailbox,
+    const gpu::Mailbox& received_mailbox,
     bool skip_frame,
     const scoped_refptr<ui::Texture>& texture_to_produce) {
   AcceleratedSurfaceMsg_BufferPresented_Params ack;
   uint32 sync_point = 0;
   DCHECK(!texture_to_produce || !skip_frame);
   if (texture_to_produce) {
     ack.mailbox_name = texture_to_produce->Produce();
     sync_point =
         content::ImageTransportFactory::GetInstance()->InsertSyncPoint();
   } else if (skip_frame) {
@@ skipping 832 matching lines @@
     }
   } else {
     window_->SetExternalTexture(NULL);
     resize_locks_.clear();
   }
 }
 
 bool RenderWidgetHostViewAura::SwapBuffersPrepare(
     const gfx::Rect& surface_rect,
     const gfx::Rect& damage_rect,
-    const std::string& mailbox_name,
+    const gpu::Mailbox& mailbox_name,
     const BufferPresentedCallback& ack_callback) {
   if (last_swapped_surface_size_ != surface_rect.size()) {
     // The surface could have shrunk since we skipped an update, in which
     // case we can expect a full update.
     DLOG_IF(ERROR, damage_rect != surface_rect) << "Expected full damage rect";
     skipped_damage_.setEmpty();
     last_swapped_surface_size_ = surface_rect.size();
   }
 
-  if (ShouldSkipFrame(surface_rect.size()) || mailbox_name.empty()) {
+  if (ShouldSkipFrame(surface_rect.size()) || mailbox_name.IsZero()) {
     skipped_damage_.op(RectToSkIRect(damage_rect), SkRegion::kUnion_Op);
     ack_callback.Run(true, scoped_refptr<ui::Texture>());
     return false;
   }
 
   ImageTransportFactory* factory = ImageTransportFactory::GetInstance();
   current_surface_ = factory->CreateTransportClient(device_scale_factor_);
   if (!current_surface_) {
     LOG(ERROR) << "Failed to create ImageTransport texture";
     ack_callback.Run(true, scoped_refptr<ui::Texture>());
@@ skipping 76 matching lines @@
 
   if (!frame.gl_frame_data->sync_point) {
     LOG(ERROR) << "CompositorFrame without sync point. Skipping frame...";
     ack_callback.Run(true, scoped_refptr<ui::Texture>());
     return;
   }
 
   ImageTransportFactory* factory = ImageTransportFactory::GetInstance();
   factory->WaitSyncPoint(frame.gl_frame_data->sync_point);
 
-  std::string mailbox_name(
-      reinterpret_cast<const char*>(frame.gl_frame_data->mailbox.name),
-      sizeof(frame.gl_frame_data->mailbox.name));
   BuffersSwapped(
-      frame.gl_frame_data->size, mailbox_name, ack_callback);
+      frame.gl_frame_data->size, frame.gl_frame_data->mailbox, ack_callback);
 }
 
 void RenderWidgetHostViewAura::BuffersSwapped(
     const gfx::Size& size,
-    const std::string& mailbox_name,
+    const gpu::Mailbox& mailbox_name,
     const BufferPresentedCallback& ack_callback) {
   scoped_refptr<ui::Texture> texture_to_return(current_surface_);
   const gfx::Rect surface_rect = gfx::Rect(gfx::Point(), size);
   if (!SwapBuffersPrepare(
       surface_rect, surface_rect, mailbox_name, ack_callback)) {
     return;
   }
 
   previous_damage_.setRect(RectToSkIRect(surface_rect));
   skipped_damage_.setEmpty();
@@ skipping 1145 matching lines @@
     RenderWidgetHost* widget) {
   return new RenderWidgetHostViewAura(widget);
 }
 
 // static
 void RenderWidgetHostViewPort::GetDefaultScreenInfo(WebScreenInfo* results) {
   GetScreenInfoForWindow(results, NULL);
 }
 
 }  // namespace content