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"
@@ skipping 61 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);
   }
 }