Remove surface_id from RenderWidget/RenderWidgetHost and friends

content/renderer/render_widget.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/render_widget.h"
 
 #include "base/auto_reset.h"
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/logging.h"
@@ skipping 464 matching lines @@
 
 // RenderWidget ---------------------------------------------------------------
 
 RenderWidget::RenderWidget(CompositorDependencies* compositor_deps,
                            blink::WebPopupType popup_type,
                            const blink::WebScreenInfo& screen_info,
                            bool swapped_out,
                            bool hidden,
                            bool never_visible)
     : routing_id_(MSG_ROUTING_NONE),
-      surface_id_(0),
       compositor_deps_(compositor_deps),
       webwidget_(nullptr),
       opener_id_(MSG_ROUTING_NONE),
       init_complete_(false),
       top_controls_shrink_blink_size_(false),
       top_controls_height_(0.f),
       next_paint_flags_(0),
       auto_resize_mode_(false),
       need_update_rect_for_auto_resize_(false),
       did_show_(false),
@@ skipping 56 matching lines @@
       compositor_deps, popup_type, screen_info, false, false, false));
   if (widget->Init(opener_id)) {  // adds reference on success.
     return widget.get();
   }
   return NULL;
 }
 
 // static
 RenderWidget* RenderWidget::CreateForFrame(
     int routing_id,
-    int surface_id,
     bool hidden,
     const blink::WebScreenInfo& screen_info,
     CompositorDependencies* compositor_deps,
     blink::WebLocalFrame* frame) {
   CHECK_NE(routing_id, MSG_ROUTING_NONE);
   scoped_refptr<RenderWidget> widget(
       new RenderWidget(compositor_deps, blink::WebPopupTypeNone, screen_info,
                        false, hidden, false));
   widget->routing_id_ = routing_id;
-  widget->surface_id_ = surface_id;
   widget->for_oopif_ = true;
   // DoInit increments the reference count on |widget|, keeping it alive after
   // this function returns.
   if (widget->DoInit(MSG_ROUTING_NONE,
                      RenderWidget::CreateWebFrameWidget(widget.get(), frame),
                      nullptr)) {
     widget->CompleteInit();
     return widget.get();
   }
   return nullptr;
@@ skipping 17 matching lines @@
       NOTREACHED();
   }
   return NULL;
 }
 
 void RenderWidget::CloseForFrame() {
   OnClose();
 }
 
 bool RenderWidget::Init(int32 opener_id) {
-  return DoInit(opener_id, RenderWidget::CreateWebWidget(this),
-                new ViewHostMsg_CreateWidget(opener_id, popup_type_,
-                                             &routing_id_, &surface_id_));
+  return DoInit(
+      opener_id, RenderWidget::CreateWebWidget(this),
+      new ViewHostMsg_CreateWidget(opener_id, popup_type_, &routing_id_));
 }
 
 bool RenderWidget::DoInit(int32 opener_id,
                           WebWidget* web_widget,
                           IPC::SyncMessage* create_widget_message) {
   DCHECK(!webwidget_);
 
   if (opener_id != MSG_ROUTING_NONE)
     opener_id_ = opener_id;
 
@@ skipping 369 matching lines @@
 }
 
 scoped_ptr<cc::OutputSurface> RenderWidget::CreateOutputSurface(bool fallback) {
   // For widgets that are never visible, we don't start the compositor, so we
   // never get a request for a cc::OutputSurface.
   DCHECK(!never_visible_);
 
 #if defined(OS_ANDROID)
   if (SynchronousCompositorFactory* factory =
       SynchronousCompositorFactory::GetInstance()) {
-    return factory->CreateOutputSurface(routing_id(), surface_id(),
+    return factory->CreateOutputSurface(routing_id(),
                                         frame_swap_message_queue_);
   }
 #endif
 
   const base::CommandLine& command_line =
       *base::CommandLine::ForCurrentProcess();
   bool use_software = fallback;
   if (command_line.HasSwitch(switches::kDisableGpuCompositing))
     use_software = true;
 
@@ skipping 1369 matching lines @@
   // to avoid unnecessarily stalling the compositor thread.
   limits.mapped_memory_reclaim_limit =
       max_transfer_buffer_usage_mb * kBytesPerMegabyte;
 #endif
   if (compositor) {
     limits.command_buffer_size = 64 * 1024;
     limits.start_transfer_buffer_size = 64 * 1024;
     limits.min_transfer_buffer_size = 64 * 1024;
   }
 
+  // TODO(piman): we still need to create a View command buffer until
+  // crbug.com/526196 is fixed. The surface_id doesn't matter, it just needs to
+  // be !0.
+  const int32 kDummySurfaceId = 1;
   scoped_ptr<WebGraphicsContext3DCommandBufferImpl> context(
-      new WebGraphicsContext3DCommandBufferImpl(surface_id(),
-                                                GetURLForGraphicsContext3D(),
-                                                gpu_channel_host.get(),
-                                                attributes,
-                                                lose_context_when_out_of_memory,
-                                                limits,
-                                                NULL));
+      new WebGraphicsContext3DCommandBufferImpl(
+          kDummySurfaceId, GetURLForGraphicsContext3D(),
+          gpu_channel_host.get(), attributes, lose_context_when_out_of_memory,
+          limits, NULL));
   return context.Pass();
 }
 
 void RenderWidget::RegisterRenderFrameProxy(RenderFrameProxy* proxy) {
   render_frame_proxies_.AddObserver(proxy);
 }
 
 void RenderWidget::UnregisterRenderFrameProxy(RenderFrameProxy* proxy) {
   render_frame_proxies_.RemoveObserver(proxy);
 }
@@ skipping 10 matching lines @@
 void RenderWidget::RegisterVideoHoleFrame(RenderFrameImpl* frame) {
   video_hole_frames_.AddObserver(frame);
 }
 
 void RenderWidget::UnregisterVideoHoleFrame(RenderFrameImpl* frame) {
   video_hole_frames_.RemoveObserver(frame);
 }
 #endif  // defined(VIDEO_HOLE)
 
 }  // namespace content