GPU compositing surface handle is no longer sent to renderer process.

content/renderer/gpu/renderer_gl_context.cc

 // Copyright (c) 2011 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/debug/trace_event.h"
 #include "base/lazy_instance.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/scoped_ptr.h"
@@ skipping 137 matching lines @@
     base::LINKER_INITIALIZED);
 
 }  // namespace anonymous
 
 RendererGLContext::~RendererGLContext() {
   Destroy();
 }
 
 RendererGLContext* RendererGLContext::CreateViewContext(
     GpuChannelHost* channel,
-    gfx::PluginWindowHandle render_surface,
     int render_view_id,
     const char* allowed_extensions,
     const int32* attrib_list,
     const GURL& active_url) {
 #if defined(ENABLE_GPU)
   scoped_ptr<RendererGLContext> context(new RendererGLContext(channel));
   if (!context->Initialize(
       true,
-      render_surface,
       render_view_id,
       gfx::Size(),
       allowed_extensions,
       attrib_list,
       active_url))
     return NULL;
 
   return context.release();
 #else
   return NULL;
@@ skipping 11 matching lines @@
 RendererGLContext* RendererGLContext::CreateOffscreenContext(
     GpuChannelHost* channel,
     const gfx::Size& size,
     const char* allowed_extensions,
     const int32* attrib_list,
     const GURL& active_url) {
 #if defined(ENABLE_GPU)
   scoped_ptr<RendererGLContext> context(new RendererGLContext(channel));
   if (!context->Initialize(
       false,
-      gfx::kNullPluginWindow,
       0,
       size,
       allowed_extensions,
       attrib_list,
       active_url))
     return NULL;
 
   return context.release();
 #else
   return NULL;
@@ skipping 180 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,
-                                   gfx::PluginWindowHandle render_surface,
                                    int render_view_id,
                                    const gfx::Size& size,
                                    const char* allowed_extensions,
                                    const int32* attrib_list,
                                    const GURL& active_url) {
   DCHECK(size.width() >= 0 && size.height() >= 0);
   TRACE_EVENT2("gpu", "RendererGLContext::Initialize",
                    "on_screen", onscreen, "num_pixels", size.GetArea());
 
   if (channel_->state() != GpuChannelHost::kConnected)
@@ skipping 25 matching lines @@
       default:
         last_error_ = BAD_ATTRIBUTE;
         attribs.push_back(NONE);
         attrib_list = NULL;
         break;
     }
   }
 
   // Create a proxy to a command buffer in the GPU process.
   if (onscreen) {
-    if (render_surface == gfx::kNullPluginWindow) {
-      LOG(ERROR) << "Invalid surface handle for onscreen context.";
-      command_buffer_ = NULL;
-    } else {
-      TRACE_EVENT0("gpu",
-                   "RendererGLContext::Initialize::CreateViewCommandBuffer");
-      command_buffer_ = channel_->CreateViewCommandBuffer(
-          render_surface,
-          render_view_id,
-          allowed_extensions,
-          attribs,
-          active_url);
-    }
+    TRACE_EVENT0("gpu",
+                 "RendererGLContext::Initialize::CreateViewCommandBuffer");
+    command_buffer_ = channel_->CreateViewCommandBuffer(
+        render_view_id,
+        allowed_extensions,
+        attribs,
+        active_url);
   } else {
     command_buffer_ = channel_->CreateOffscreenCommandBuffer(
         size,
         allowed_extensions,
         attribs,
         active_url);
   }
   if (!command_buffer_) {
     Destroy();
     return false;
@@ skipping 128 matching lines @@
 
 bool RendererGLContext::GetParentToChildLatch(uint32* parent_to_child_latch) {
   *parent_to_child_latch = parent_to_child_latch_;
   return true;
 }
 
 bool RendererGLContext::GetChildToParentLatch(uint32* child_to_parent_latch) {
   *child_to_parent_latch = child_to_parent_latch_;
   return true;
 }