Remove the assumption about client_id from gpu memory buffer allocation on the browser side.

content/browser/gpu/browser_gpu_channel_host_factory.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/gpu/browser_gpu_channel_host_factory.h"
 
 #include "base/bind.h"
 #include "base/debug/trace_event.h"
 #include "base/synchronization/waitable_event.h"
 #include "base/threading/thread_restrictions.h"
@@ skipping 25 matching lines @@
   base::WaitableEvent event;
   int gpu_host_id;
   int32 route_id;
   CreateCommandBufferResult result;
 };
 
 struct BrowserGpuChannelHostFactory::AllocateGpuMemoryBufferRequest {
   AllocateGpuMemoryBufferRequest(size_t width,
                                  size_t height,
                                  unsigned internalformat,
-                                 unsigned usage)
+                                 unsigned usage,
+                                 int gpu_client_id)
       : event(true, false),
         width(width),
         height(height),
         internalformat(internalformat),
-        usage(usage) {}
+        usage(usage),
+        gpu_client_id(gpu_client_id) {}
   ~AllocateGpuMemoryBufferRequest() {}
   base::WaitableEvent event;
   size_t width;
   size_t height;
   unsigned internalformat;
   unsigned usage;
+  int gpu_client_id;

[reveman, 2014/09/10 16:10:13]

nit: s/gpu_client_id/client_id/

   scoped_ptr<gfx::GpuMemoryBuffer> result;
 };
 
 class BrowserGpuChannelHostFactory::EstablishRequest
     : public base::RefCountedThreadSafe<EstablishRequest> {
  public:
   static scoped_refptr<EstablishRequest> Create(CauseForGpuLaunch cause,
                                                 int gpu_client_id,
                                                 int gpu_host_id);
   void Wait();
@@ skipping 312 matching lines @@
   established_callbacks_.clear();
 }
 
 scoped_ptr<gfx::GpuMemoryBuffer>
 BrowserGpuChannelHostFactory::AllocateGpuMemoryBuffer(size_t width,
                                                       size_t height,
                                                       unsigned internalformat,
                                                       unsigned usage) {
   DCHECK(!BrowserThread::CurrentlyOn(BrowserThread::IO));
 
-  AllocateGpuMemoryBufferRequest request(width, height, internalformat, usage);
+  AllocateGpuMemoryBufferRequest request(
+      width, height, internalformat, usage, gpu_client_id_);
   GetIOLoopProxy()->PostTask(
       FROM_HERE,
       base::Bind(&BrowserGpuChannelHostFactory::AllocateGpuMemoryBufferOnIO,
                  base::Unretained(&request)));
 
   // We're blocking the UI thread, which is generally undesirable.
   TRACE_EVENT0("browser",
                "BrowserGpuChannelHostFactory::AllocateGpuMemoryBuffer");
   base::ThreadRestrictions::ScopedAllowWait allow_wait;
   request.event.Wait();
@@ skipping 51 matching lines @@
       !GpuMemoryBufferImpl::IsUsageValid(request->usage)) {
     request->result = scoped_ptr<gfx::GpuMemoryBuffer>();
     request->event.Signal();
     return;
   }
 
   GpuMemoryBufferImpl::Create(
       gfx::Size(request->width, request->height),
       request->internalformat,
       request->usage,
+      request->gpu_client_id,
       base::Bind(&BrowserGpuChannelHostFactory::OnGpuMemoryBufferCreated,
                  base::Unretained(request)));
 }
 
 // static
 void BrowserGpuChannelHostFactory::DeleteGpuMemoryBufferOnIO(
     scoped_ptr<gfx::GpuMemoryBuffer> buffer) {
 }
 
 // static
 void BrowserGpuChannelHostFactory::OnGpuMemoryBufferCreated(
     AllocateGpuMemoryBufferRequest* request,
     scoped_ptr<GpuMemoryBufferImpl> buffer) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
 
   request->result = buffer.PassAs<gfx::GpuMemoryBuffer>();
   request->event.Signal();
 }
 
 }  // namespace content