gpu: reference target surfaces through a globally unique surface id.

content/renderer/gpu/renderer_gl_context.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/renderer/gpu/renderer_gl_context.h"
 
 #include "base/bind.h"
 #include "base/debug/trace_event.h"
 #include "base/lazy_instance.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/memory/singleton.h"
 #include "base/memory/weak_ptr.h"
 #include "base/shared_memory.h"
 #include "content/common/view_messages.h"
 #include "content/renderer/gpu/command_buffer_proxy.h"
 #include "content/renderer/gpu/gpu_channel_host.h"
 #include "content/renderer/render_widget.h"
 #include "googleurl/src/gurl.h"
 #include "ipc/ipc_channel_handle.h"
 

[jonathan.backer, 2012/01/16 19:47:26]

nit: extra \n

[piman, 2012/01/17 19:40:54]

Done.

+
 #if defined(ENABLE_GPU)
 #include "gpu/command_buffer/client/gles2_cmd_helper.h"
 #include "gpu/command_buffer/client/gles2_implementation.h"
 #include "gpu/command_buffer/client/gles2_lib.h"
 #include "gpu/command_buffer/common/constants.h"
 #endif  // ENABLE_GPU
 
 namespace {
 
 const int32 kCommandBufferSize = 1024 * 1024;
@@ skipping 40 matching lines @@
 #endif
 
 }  // namespace anonymous
 
 RendererGLContext::~RendererGLContext() {
   Destroy();
 }
 
 RendererGLContext* RendererGLContext::CreateViewContext(
     GpuChannelHost* channel,
-    int render_view_id,
+    int32 surface_id,
     RendererGLContext* share_group,
     const char* allowed_extensions,
     const int32* attrib_list,
     const GURL& active_url,
     gfx::GpuPreference gpu_preference) {
 #if defined(ENABLE_GPU)
   scoped_ptr<RendererGLContext> context(new RendererGLContext(channel));
   if (!context->Initialize(
       true,
-      render_view_id,
+      surface_id,
       gfx::Size(),
       share_group,
       allowed_extensions,
       attrib_list,
       active_url,
       gpu_preference))
     return NULL;
 
   return context.release();
 #else
@@ skipping 179 matching lines @@
       command_buffer_(NULL),
       gles2_helper_(NULL),
       transfer_buffer_id_(-1),
       gles2_implementation_(NULL),
       last_error_(SUCCESS),
       frame_number_(0) {
   DCHECK(channel);
 }
 
 bool RendererGLContext::Initialize(bool onscreen,
-                                   int render_view_id,
+                                   int32 surface_id,
                                    const gfx::Size& size,
                                    RendererGLContext* share_group,
                                    const char* allowed_extensions,
                                    const int32* attrib_list,
                                    const GURL& active_url,
                                    gfx::GpuPreference gpu_preference) {
   DCHECK(CalledOnValidThread());
   DCHECK(size.width() >= 0 && size.height() >= 0);
   TRACE_EVENT2("gpu", "RendererGLContext::Initialize",
                    "on_screen", onscreen, "num_pixels", size.GetArea());
@@ skipping 38 matching lines @@
         attrib_list = NULL;
         break;
     }
   }
 
   // Create a proxy to a command buffer in the GPU process.
   if (onscreen) {
     TRACE_EVENT0("gpu",
                  "RendererGLContext::Initialize::CreateViewCommandBuffer");
     command_buffer_ = channel_->CreateViewCommandBuffer(
-        render_view_id,
+        surface_id,
         share_group ? share_group->command_buffer_ : NULL,
         allowed_extensions,
         attribs,
         active_url,
         gpu_preference);
   } else {
     command_buffer_ = channel_->CreateOffscreenCommandBuffer(
         size,
         share_group ? share_group->command_buffer_ : NULL,
         allowed_extensions,
@@ skipping 94 matching lines @@
 void RendererGLContext::OnContextLost() {
   if (!context_lost_callback_.is_null()) {
     RendererGLContext::ContextLostReason reason = kUnknown;
     if (command_buffer_) {
       reason = ConvertReason(
           command_buffer_->GetLastState().context_lost_reason);
     }
     context_lost_callback_.Run(reason);
   }
 }