Simplify ppapi Graphics3D size propagation a bit

ppapi/proxy/ppb_graphics_3d_proxy.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 "ppapi/proxy/ppb_graphics_3d_proxy.h"
 
 #include "base/numerics/safe_conversions.h"
 #include "build/build_config.h"
 #include "gpu/command_buffer/client/gles2_implementation.h"
 #include "gpu/command_buffer/common/command_buffer.h"
@@ skipping 30 matching lines @@
 #endif  // !defined(OS_NACL)
 
 gpu::CommandBuffer::State GetErrorState() {
   gpu::CommandBuffer::State error_state;
   error_state.error = gpu::error::kGenericError;
   return error_state;
 }
 
 }  // namespace
 
-Graphics3D::Graphics3D(const HostResource& resource)
-    : PPB_Graphics3D_Shared(resource) {
+Graphics3D::Graphics3D(const HostResource& resource, const gfx::Size& size)
+    : PPB_Graphics3D_Shared(resource, size) {
 }
 
 Graphics3D::~Graphics3D() {
   DestroyGLES2Impl();
 }
 
 bool Graphics3D::Init(gpu::gles2::GLES2Implementation* share_gles2,
                       const gpu::Capabilities& capabilities,
                       const SerializedHandle& shared_state,
                       gpu::CommandBufferId command_buffer_id) {
@@ skipping 48 matching lines @@
 
 gpu::CommandBuffer* Graphics3D::GetCommandBuffer() {
   return command_buffer_.get();
 }
 
 gpu::GpuControl* Graphics3D::GetGpuControl() {
   return command_buffer_.get();
 }
 
 int32_t Graphics3D::DoSwapBuffers(const gpu::SyncToken& sync_token,
-                                  int32_t width,
-                                  int32_t height) {
+                                  const gfx::Size& size) {
   // A valid sync token would indicate a swap buffer already happened somehow.
   DCHECK(!sync_token.HasData());
 
   gpu::gles2::GLES2Implementation* gl = gles2_impl();
   gl->SwapBuffers();
 
   PluginDispatcher::GetForResource(this)->Send(
       new PpapiHostMsg_PPBGraphics3D_TakeFrontBuffer(API_ID_PPB_GRAPHICS_3D,
                                                      host_resource()));
 
   const GLuint64 fence_sync = gl->InsertFenceSyncCHROMIUM();
   gl->ShallowFlushCHROMIUM();
 
   gpu::SyncToken new_sync_token;
   gl->GenSyncTokenCHROMIUM(fence_sync, new_sync_token.GetData());
 
   IPC::Message* msg = new PpapiHostMsg_PPBGraphics3D_SwapBuffers(
-      API_ID_PPB_GRAPHICS_3D, host_resource(), new_sync_token, width,
-      height);
+      API_ID_PPB_GRAPHICS_3D, host_resource(), new_sync_token, size);
   msg->set_unblock(true);
   PluginDispatcher::GetForResource(this)->Send(msg);
 
   return PP_OK_COMPLETIONPENDING;
 }
 
 PPB_Graphics3D_Proxy::PPB_Graphics3D_Proxy(Dispatcher* dispatcher)
     : InterfaceProxy(dispatcher),
       callback_factory_(this) {
 }
@@ skipping 56 matching lines @@
   gpu::Capabilities capabilities;
   ppapi::proxy::SerializedHandle shared_state;
   gpu::CommandBufferId command_buffer_id;
   dispatcher->Send(new PpapiHostMsg_PPBGraphics3D_Create(
       API_ID_PPB_GRAPHICS_3D, instance, share_host, attrib_helper, &result,
       &capabilities, &shared_state, &command_buffer_id));
 
   if (result.is_null())
     return 0;
 
-  scoped_refptr<Graphics3D> graphics_3d(new Graphics3D(result));
+  scoped_refptr<Graphics3D> graphics_3d(
+      new Graphics3D(result, attrib_helper.offscreen_framebuffer_size));
   if (!graphics_3d->Init(share_gles2, capabilities, shared_state,
                          command_buffer_id)) {
     return 0;
   }
   return graphics_3d->GetReference();
 }
 
 bool PPB_Graphics3D_Proxy::OnMessageReceived(const IPC::Message& msg) {
   bool handled = true;
   IPC_BEGIN_MESSAGE_MAP(PPB_Graphics3D_Proxy, msg)
@@ skipping 125 matching lines @@
 void PPB_Graphics3D_Proxy::OnMsgDestroyTransferBuffer(
     const HostResource& context,
     int32_t id) {
   EnterHostFromHostResource<PPB_Graphics3D_API> enter(context);
   if (enter.succeeded())
     enter.object()->DestroyTransferBuffer(id);
 }
 
 void PPB_Graphics3D_Proxy::OnMsgSwapBuffers(const HostResource& context,
                                             const gpu::SyncToken& sync_token,
-                                            int32_t width,
-                                            int32_t height) {
+                                            const gfx::Size& size) {
   EnterHostFromHostResourceForceCallback<PPB_Graphics3D_API> enter(
       context, callback_factory_,
       &PPB_Graphics3D_Proxy::SendSwapBuffersACKToPlugin, context);
   if (enter.succeeded())
     enter.SetResult(enter.object()->SwapBuffersWithSyncToken(
-        enter.callback(), sync_token, width, height));
+        enter.callback(), sync_token, size));
 }
 
 void PPB_Graphics3D_Proxy::OnMsgTakeFrontBuffer(const HostResource& context) {
   EnterHostFromHostResource<PPB_Graphics3D_API> enter(context);
   if (enter.succeeded())
     enter.object()->TakeFrontBuffer();
 }
 
 void PPB_Graphics3D_Proxy::OnMsgEnsureWorkVisible(const HostResource& context) {
   EnterHostFromHostResource<PPB_Graphics3D_API> enter(context);
@@ skipping 13 matching lines @@
 void PPB_Graphics3D_Proxy::SendSwapBuffersACKToPlugin(
     int32_t result,
     const HostResource& context) {
   dispatcher()->Send(new PpapiMsg_PPBGraphics3D_SwapBuffersACK(
       API_ID_PPB_GRAPHICS_3D, context, result));
 }
 #endif  // !defined(OS_NACL)
 
 }  // namespace proxy
 }  // namespace ppapi