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

content/common/gpu/texture_image_transport_surface.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/common/gpu/texture_image_transport_surface.h"
 
 #include <string>
 #include <vector>
 
 #include "base/command_line.h"
@@ skipping 200 matching lines @@
 
   if (!backbuffer_.get()) {
     LOG(ERROR) << "Swap without valid backing.";
     return true;
   }
 
   DCHECK(backbuffer_size() == current_size_);
   GpuHostMsg_AcceleratedSurfaceBuffersSwapped_Params params;
   params.size = backbuffer_size();
   params.scale_factor = scale_factor_;
-  params.mailbox_name.assign(
-      reinterpret_cast<const char*>(&back_mailbox_),
-      sizeof(back_mailbox_));
+  params.mailbox = back_mailbox_;
 
   glFlush();
 
   params.latency_info.swap(latency_info_);
   helper_->SendAcceleratedSurfaceBuffersSwapped(params);
 
   DCHECK(!is_swap_buffers_pending_);
   is_swap_buffers_pending_ = true;
   return true;
 }
@@ skipping 17 matching lines @@
   }
 
   DCHECK(current_size_ == backbuffer_size());
   GpuHostMsg_AcceleratedSurfacePostSubBuffer_Params params;
   params.surface_size = backbuffer_size();
   params.surface_scale_factor = scale_factor_;
   params.x = x;
   params.y = y;
   params.width = width;
   params.height = height;
-  params.mailbox_name.assign(
-      reinterpret_cast<const char*>(&back_mailbox_),
-      sizeof(back_mailbox_));
+  params.mailbox = back_mailbox_;
 
   glFlush();
 
   params.latency_info.swap(latency_info_);
   helper_->SendAcceleratedSurfacePostSubBuffer(params);
 
   DCHECK(!is_swap_buffers_pending_);
   is_swap_buffers_pending_ = true;
   return true;
 }
@@ skipping 13 matching lines @@
   return surface_.get() ? surface_->GetHandle() : NULL;
 }
 
 unsigned TextureImageTransportSurface::GetFormat() {
   return surface_.get() ? surface_->GetFormat() : 0;
 }
 
 void TextureImageTransportSurface::OnBufferPresented(
     const AcceleratedSurfaceMsg_BufferPresented_Params& params) {
   if (params.sync_point == 0) {
-    BufferPresentedImpl(params.mailbox_name);
+    BufferPresentedImpl(params.mailbox);
   } else {
     helper_->manager()->sync_point_manager()->AddSyncPointCallback(
         params.sync_point,
         base::Bind(&TextureImageTransportSurface::BufferPresentedImpl,
                    this,
-                   params.mailbox_name));
+                   params.mailbox));
   }
 }
 
-void TextureImageTransportSurface::BufferPresentedImpl(
-    const std::string& mailbox_name) {
+void TextureImageTransportSurface::BufferPresentedImpl(const Mailbox& mailbox) {
   DCHECK(is_swap_buffers_pending_);
   is_swap_buffers_pending_ = false;
 
   // When we wait for a sync point, we may get called back after the stub is
   // destroyed. In that case there's no need to do anything with the returned
   // mailbox.
   if (stub_destroyed_)
     return;
 
   // We should not have allowed the backbuffer to be discarded while the ack
   // was pending.
   DCHECK(backbuffer_suggested_allocation_);
   DCHECK(backbuffer_.get());
 
   bool swap = true;
-  if (!mailbox_name.empty()) {
-    DCHECK(mailbox_name.length() == GL_MAILBOX_SIZE_CHROMIUM);
-    if (!memcmp(mailbox_name.data(),
-                &back_mailbox_,
-                mailbox_name.length())) {
+  if (!mailbox.IsZero()) {
+    if (mailbox == back_mailbox_) {
       // The browser has skipped the frame to unblock the GPU process, waiting
       // for one of the right size, and returned the back buffer, so don't swap.
       swap = false;
     }
   }
   if (swap) {
     std::swap(backbuffer_, frontbuffer_);
     std::swap(back_mailbox_, front_mailbox_);
   }
 
@@ skipping 120 matching lines @@
 
 #ifndef NDEBUG
   GLenum status = glCheckFramebufferStatusEXT(GL_FRAMEBUFFER);
   if (status != GL_FRAMEBUFFER_COMPLETE) {
     DLOG(FATAL) << "Framebuffer incomplete: " << status;
   }
 #endif
 }
 
 }  // namespace content