Remove 'transport' paths from PassThroughImageTransportSurface

content/common/gpu/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/image_transport_surface.h"
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/command_line.h"
 #include "base/debug/trace_event.h"
@@ skipping 68 matching lines @@
   return true;
 }
 
 void ImageTransportHelper::Destroy() {}
 
 bool ImageTransportHelper::OnMessageReceived(const IPC::Message& message) {
   bool handled = true;
   IPC_BEGIN_MESSAGE_MAP(ImageTransportHelper, message)
     IPC_MESSAGE_HANDLER(AcceleratedSurfaceMsg_BufferPresented,
                         OnBufferPresented)
-    IPC_MESSAGE_HANDLER(AcceleratedSurfaceMsg_ResizeViewACK, OnResizeViewACK);
     IPC_MESSAGE_HANDLER(AcceleratedSurfaceMsg_WakeUpGpu, OnWakeUpGpu);
     IPC_MESSAGE_UNHANDLED(handled = false)
   IPC_END_MESSAGE_MAP()
   return handled;
 }
 
 void ImageTransportHelper::SendAcceleratedSurfaceBuffersSwapped(
     GpuHostMsg_AcceleratedSurfaceBuffersSwapped_Params params) {
   // TRACE_EVENT for gpu tests:
   TRACE_EVENT_INSTANT2("test_gpu", "SwapBuffers",
@@ skipping 11 matching lines @@
   params.route_id = route_id_;
   manager_->Send(new GpuHostMsg_AcceleratedSurfacePostSubBuffer(params));
 }
 
 void ImageTransportHelper::SendAcceleratedSurfaceRelease() {
   GpuHostMsg_AcceleratedSurfaceRelease_Params params;
   params.surface_id = stub_->surface_id();
   manager_->Send(new GpuHostMsg_AcceleratedSurfaceRelease(params));
 }
 
-void ImageTransportHelper::SendResizeView(const gfx::Size& size) {
-  manager_->Send(new GpuHostMsg_ResizeView(stub_->surface_id(),
-                                           route_id_,
-                                           size));
-}
-
 void ImageTransportHelper::SendUpdateVSyncParameters(
       base::TimeTicks timebase, base::TimeDelta interval) {
   manager_->Send(new GpuHostMsg_UpdateVSyncParameters(stub_->surface_id(),
                                                       timebase,
                                                       interval));
 }
 
 void ImageTransportHelper::SendLatencyInfo(
     const std::vector<ui::LatencyInfo>& latency_info) {
   manager_->Send(new GpuHostMsg_FrameDrawn(latency_info));
@@ skipping 47 matching lines @@
   if (!stub_.get())
     return NULL;
   return stub_->decoder();
 }
 
 void ImageTransportHelper::OnBufferPresented(
     const AcceleratedSurfaceMsg_BufferPresented_Params& params) {
   surface_->OnBufferPresented(params);
 }
 
-void ImageTransportHelper::OnResizeViewACK() {
-  surface_->OnResizeViewACK();
-}
-
 void ImageTransportHelper::OnWakeUpGpu() {
   surface_->WakeUpGpu();
 }
 
 void ImageTransportHelper::Resize(gfx::Size size, float scale_factor) {
   surface_->OnResize(size, scale_factor);
 
 #if defined(OS_ANDROID)
   manager_->gpu_memory_manager()->ScheduleManage(
       GpuMemoryManager::kScheduleManageNow);
 #endif
 }
 
 void ImageTransportHelper::SetLatencyInfo(
     const std::vector<ui::LatencyInfo>& latency_info) {
   surface_->SetLatencyInfo(latency_info);
 }
 
 PassThroughImageTransportSurface::PassThroughImageTransportSurface(
     GpuChannelManager* manager,
     GpuCommandBufferStub* stub,
-    gfx::GLSurface* surface,
-    bool transport)
+    gfx::GLSurface* surface)
     : GLSurfaceAdapter(surface),
-      transport_(transport),
-      did_set_swap_interval_(false),
-      did_unschedule_(false),
-      is_swap_buffers_pending_(false) {
+      did_set_swap_interval_(false) {
   helper_.reset(new ImageTransportHelper(this,
                                          manager,
                                          stub,
                                          gfx::kNullPluginWindow));
 }
 
 bool PassThroughImageTransportSurface::Initialize() {
   // The surface is assumed to have already been initialized.
   return helper_->Initialize();
 }
 
 void PassThroughImageTransportSurface::Destroy() {
   helper_->Destroy();
   GLSurfaceAdapter::Destroy();
 }
 
-bool PassThroughImageTransportSurface::DeferDraws() {
-  if (is_swap_buffers_pending_) {
-    DCHECK(!did_unschedule_);
-    did_unschedule_ = true;
-    helper_->SetScheduled(false);
-    return true;
-  }
-  return false;
-}
-
 void PassThroughImageTransportSurface::SetLatencyInfo(
     const std::vector<ui::LatencyInfo>& latency_info) {
   for (size_t i = 0; i < latency_info.size(); i++)
     latency_info_.push_back(latency_info[i]);
 }
 
 bool PassThroughImageTransportSurface::SwapBuffers() {
   // GetVsyncValues before SwapBuffers to work around Mali driver bug:
   // crbug.com/223558.
   SendVSyncUpdateIfAvailable();
   bool result = gfx::GLSurfaceAdapter::SwapBuffers();
   for (size_t i = 0; i < latency_info_.size(); i++) {
     latency_info_[i].AddLatencyNumber(
         ui::INPUT_EVENT_LATENCY_TERMINATED_FRAME_SWAP_COMPONENT, 0, 0);
   }
 
-  if (transport_) {
-    DCHECK(!is_swap_buffers_pending_);
-    is_swap_buffers_pending_ = true;
-
-    // Round trip to the browser UI thread, for throttling, by sending a dummy
-    // SwapBuffers message.
-    GpuHostMsg_AcceleratedSurfaceBuffersSwapped_Params params;
-    params.surface_handle = 0;
-    params.latency_info.swap(latency_info_);
-    params.size = surface()->GetSize();
-    helper_->SendAcceleratedSurfaceBuffersSwapped(params);
-  } else {
-    helper_->SendLatencyInfo(latency_info_);
-  }
+  helper_->SendLatencyInfo(latency_info_);
   latency_info_.clear();
   return result;
 }
 
 bool PassThroughImageTransportSurface::PostSubBuffer(
     int x, int y, int width, int height) {
   SendVSyncUpdateIfAvailable();
   bool result = gfx::GLSurfaceAdapter::PostSubBuffer(x, y, width, height);
   for (size_t i = 0; i < latency_info_.size(); i++) {
     latency_info_[i].AddLatencyNumber(
         ui::INPUT_EVENT_LATENCY_TERMINATED_FRAME_SWAP_COMPONENT, 0, 0);
   }
 
-  if (transport_) {
-    DCHECK(!is_swap_buffers_pending_);
-    is_swap_buffers_pending_ = true;
-
-    // Round trip to the browser UI thread, for throttling, by sending a dummy
-    // PostSubBuffer message.
-    GpuHostMsg_AcceleratedSurfacePostSubBuffer_Params params;
-    params.surface_handle = 0;
-    params.latency_info.swap(latency_info_);
-    params.surface_size = surface()->GetSize();
-    params.x = x;
-    params.y = y;
-    params.width = width;
-    params.height = height;
-    helper_->SendAcceleratedSurfacePostSubBuffer(params);
-
-    helper_->SetScheduled(false);
-  } else {
-    helper_->SendLatencyInfo(latency_info_);
-  }
+  helper_->SendLatencyInfo(latency_info_);
   latency_info_.clear();
   return result;
 }
 
 bool PassThroughImageTransportSurface::OnMakeCurrent(gfx::GLContext* context) {
   if (!did_set_swap_interval_) {
     ImageTransportHelper::SetSwapInterval(context);
     did_set_swap_interval_ = true;
   }
   return true;
 }
 
 void PassThroughImageTransportSurface::OnBufferPresented(
     const AcceleratedSurfaceMsg_BufferPresented_Params& /* params */) {
-  DCHECK(transport_);
-  DCHECK(is_swap_buffers_pending_);
-  is_swap_buffers_pending_ = false;
-  if (did_unschedule_) {
-    did_unschedule_ = false;
-    helper_->SetScheduled(true);
-  }
-}
-
-void PassThroughImageTransportSurface::OnResizeViewACK() {
-  DCHECK(transport_);
-  Resize(new_size_);
-
-  TRACE_EVENT_ASYNC_END0("gpu", "OnResize", this);
-  helper_->SetScheduled(true);
+  NOTREACHED();
 }
 
 void PassThroughImageTransportSurface::OnResize(gfx::Size size,
                                                 float scale_factor) {
-  new_size_ = size;
-
-  if (transport_) {
-    helper_->SendResizeView(size);
-    helper_->SetScheduled(false);
-    TRACE_EVENT_ASYNC_BEGIN2("gpu", "OnResize", this,
-                             "width", size.width(), "height", size.height());
-  } else {
-    Resize(new_size_);
-  }
+  Resize(size);
 }
 
 gfx::Size PassThroughImageTransportSurface::GetSize() {
   return GLSurfaceAdapter::GetSize();
 }
 
 void PassThroughImageTransportSurface::WakeUpGpu() {
   NOTIMPLEMENTED();
 }
 
 PassThroughImageTransportSurface::~PassThroughImageTransportSurface() {}
 
 void PassThroughImageTransportSurface::SendVSyncUpdateIfAvailable() {
   gfx::VSyncProvider* vsync_provider = GetVSyncProvider();
   if (vsync_provider) {
     vsync_provider->GetVSyncParameters(
       base::Bind(&ImageTransportHelper::SendUpdateVSyncParameters,
                  helper_->AsWeakPtr()));
   }
 }
 
 }  // namespace content