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

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/auto_reset.h"
 #include "base/basictypes.h"
 #include "base/bind.h"
 #include "base/callback_helpers.h"
@@ skipping 309 matching lines @@
     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.get() || !skip_frame);
   if (texture_to_produce.get()) {
     GLHelper* gl_helper = ImageTransportFactory::GetInstance()->GetGLHelper();
-    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 =
         gl_helper ? gl_helper->InsertSyncPoint() : 0;
   } 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, output_surface_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.get() || !skip_frame);
   if (texture_to_produce.get()) {
     GLHelper* gl_helper = ImageTransportFactory::GetInstance()->GetGLHelper();
-    ack.mailbox_name = texture_to_produce->Produce();
+    ack.mailbox = texture_to_produce->Produce();
     sync_point = gl_helper ? gl_helper->InsertSyncPoint() : 0;
   } else if (skip_frame) {
-    ack.mailbox_name = received_mailbox;
+    ack.mailbox = received_mailbox;
     ack.sync_point = 0;
   }
 
   ack.sync_point = sync_point;
   RenderWidgetHostImpl::AcknowledgeBufferPresent(
       route_id, gpu_host_id, ack);
 }
 
 }  // namespace
 
@@ skipping 922 matching lines @@
     resize_lock_.reset();
     host_->WasResized();
     software_frame_manager_->DiscardCurrentFrame();
   }
 }
 
 bool RenderWidgetHostViewAura::SwapBuffersPrepare(
     const gfx::Rect& surface_rect,
     float surface_scale_factor,
     const gfx::Rect& damage_rect,
-    const std::string& mailbox_name,
+    const gpu::Mailbox& mailbox,
     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();
     last_swapped_surface_scale_factor_ = surface_scale_factor;
   }
 
   if (ShouldSkipFrame(ConvertSizeToDIP(surface_scale_factor,
                                        surface_rect.size())) ||
-      mailbox_name.empty()) {
+      mailbox.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(surface_scale_factor);
   if (!current_surface_.get()) {
     LOG(ERROR) << "Failed to create ImageTransport texture";
     ack_callback.Run(true, scoped_refptr<ui::Texture>());
     return false;
   }
 
-  current_surface_->Consume(mailbox_name, surface_rect.size());
+  current_surface_->Consume(mailbox, surface_rect.size());
   released_front_lock_ = NULL;
   UpdateExternalTexture();
 
   return true;
 }
 
 void RenderWidgetHostViewAura::SwapBuffersCompleted(
     const BufferPresentedCallback& ack_callback,
     const scoped_refptr<ui::Texture>& texture_to_return) {
   ui::Compositor* compositor = GetCompositor();
@@ skipping 45 matching lines @@
 }
 #endif
 
 void RenderWidgetHostViewAura::AcceleratedSurfaceBuffersSwapped(
     const GpuHostMsg_AcceleratedSurfaceBuffersSwapped_Params& params_in_pixel,
     int gpu_host_id) {
   BufferPresentedCallback ack_callback = base::Bind(
       &AcknowledgeBufferForGpu,
       params_in_pixel.route_id,
       gpu_host_id,
-      params_in_pixel.mailbox_name);
+      params_in_pixel.mailbox);
   BuffersSwapped(params_in_pixel.size,
                  gfx::Rect(params_in_pixel.size),
                  params_in_pixel.scale_factor,
-                 params_in_pixel.mailbox_name,
+                 params_in_pixel.mailbox,
                  params_in_pixel.latency_info,
                  ack_callback);
 }
 
 void RenderWidgetHostViewAura::SwapDelegatedFrame(
     uint32 output_surface_id,
     scoped_ptr<cc::DelegatedFrameData> frame_data,
     float frame_device_scale_factor,
     const std::vector<ui::LatencyInfo>& latency_info) {
   DCHECK_NE(0u, frame_data->render_pass_list.size());
@@ skipping 270 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;
   }
 
   GLHelper* gl_helper = ImageTransportFactory::GetInstance()->GetGLHelper();
   gl_helper->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,
                  frame->gl_frame_data->sub_buffer_rect,
                  frame->metadata.device_scale_factor,
-                 mailbox_name,
+                 frame->gl_frame_data->mailbox,
                  frame->metadata.latency_info,
                  ack_callback);
 }
 
 #if defined(OS_WIN)
 void RenderWidgetHostViewAura::SetParentNativeViewAccessible(
     gfx::NativeViewAccessible accessible_parent) {
   if (GetBrowserAccessibilityManager()) {
     GetBrowserAccessibilityManager()->ToBrowserAccessibilityManagerWin()
         ->set_parent_iaccessible(accessible_parent);
   }
 }
 
 gfx::NativeViewId RenderWidgetHostViewAura::GetParentForWindowlessPlugin()
     const {
   if (legacy_render_widget_host_HWND_) {
     return reinterpret_cast<gfx::NativeViewId>(
         legacy_render_widget_host_HWND_->hwnd());
   }
   return NULL;
 }
 #endif
 
 void RenderWidgetHostViewAura::BuffersSwapped(
     const gfx::Size& surface_size,
     const gfx::Rect& damage_rect,
     float surface_scale_factor,
-    const std::string& mailbox_name,
+    const gpu::Mailbox& mailbox,
     const std::vector<ui::LatencyInfo>& latency_info,
     const BufferPresentedCallback& ack_callback) {
   scoped_refptr<ui::Texture> previous_texture(current_surface_);
   const gfx::Rect surface_rect = gfx::Rect(surface_size);
   software_frame_manager_->DiscardCurrentFrame();
 
   if (!SwapBuffersPrepare(surface_rect,
                           surface_scale_factor,
                           damage_rect,
-                          mailbox_name,
+                          mailbox,
                           ack_callback)) {
     return;
   }
 
   SkRegion damage(RectToSkIRect(damage_rect));
   if (!skipped_damage_.isEmpty()) {
     damage.op(skipped_damage_, SkRegion::kUnion_Op);
     skipped_damage_.setEmpty();
   }
 
@@ skipping 46 matching lines @@
     const GpuHostMsg_AcceleratedSurfacePostSubBuffer_Params& params_in_pixel,
     int gpu_host_id) {
   gfx::Rect damage_rect(params_in_pixel.x,
                         params_in_pixel.y,
                         params_in_pixel.width,
                         params_in_pixel.height);
   BufferPresentedCallback ack_callback =
       base::Bind(&AcknowledgeBufferForGpu,
                  params_in_pixel.route_id,
                  gpu_host_id,
-                 params_in_pixel.mailbox_name);
+                 params_in_pixel.mailbox);
   BuffersSwapped(params_in_pixel.surface_size,
                  damage_rect,
                  params_in_pixel.surface_scale_factor,
-                 params_in_pixel.mailbox_name,
+                 params_in_pixel.mailbox,
                  params_in_pixel.latency_info,
                  ack_callback);
 }
 
 void RenderWidgetHostViewAura::AcceleratedSurfaceSuspend() {
 }
 
 void RenderWidgetHostViewAura::AcceleratedSurfaceRelease() {
   // This really tells us to release the frontbuffer.
   if (current_surface_.get()) {
@@ skipping 1788 matching lines @@
     RenderWidgetHost* widget) {
   return new RenderWidgetHostViewAura(widget);
 }
 
 // static
 void RenderWidgetHostViewPort::GetDefaultScreenInfo(WebScreenInfo* results) {
   GetScreenInfoForWindow(results, NULL);
 }
 
 }  // namespace content