cc: Make OutputSurface::BindToClient pure virtual and not return bool

content/browser/compositor/gpu_browser_compositor_output_surface.cc

 // Copyright 2014 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/compositor/gpu_browser_compositor_output_surface.h"
 
 #include <utility>
 
 #include "build/build_config.h"
 #include "cc/output/output_surface_client.h"
@@ skipping 12 matching lines @@
 GpuBrowserCompositorOutputSurface::GpuBrowserCompositorOutputSurface(
     scoped_refptr<ContextProviderCommandBuffer> context,
     scoped_refptr<ui::CompositorVSyncManager> vsync_manager,
     cc::SyntheticBeginFrameSource* begin_frame_source,
     std::unique_ptr<display_compositor::CompositorOverlayCandidateValidator>
         overlay_candidate_validator)
     : BrowserCompositorOutputSurface(std::move(context),
                                      std::move(vsync_manager),
                                      begin_frame_source,
                                      std::move(overlay_candidate_validator)),
-      weak_ptr_factory_(this) {}
+      weak_ptr_factory_(this) {
+  if (capabilities_.uses_default_gl_framebuffer) {
+    capabilities_.flipped_output_surface =
+        context_provider()->ContextCapabilities().flips_vertically;

[boliu, 2016/10/25 00:07:35]

is accessing the context safe here? or is the assumption here that browser
compositor is single threaded, so BindtoClient and all other context access also
happen on the UI thread?

basically the same question for all the content changes

[danakj, 2016/10/25 00:11:01]

Yes OutputSurface is now single-threaded. Display compositor does not use
multiple threads like LTHI (used to in the browser process sometimes)

The context is always bound before being handed to the OutputSurface now in GPTF
or CompositorImplAndroid

[danakj, 2016/10/25 00:11:44]

Here's where for GPTF:
https://cs.chromium.org/chromium/src/content/browser/compositor/gpu_process_t...

+  }
+}
 
 GpuBrowserCompositorOutputSurface::~GpuBrowserCompositorOutputSurface() =
     default;
 
 void GpuBrowserCompositorOutputSurface::OnGpuSwapBuffersCompleted(
     const std::vector<ui::LatencyInfo>& latency_info,
     gfx::SwapResult result,
     const gpu::GpuProcessHostedCALayerTreeParamsMac* params_mac) {
   RenderWidgetHostImpl::CompositorFrameDrawn(latency_info);
   client_->DidReceiveSwapBuffersAck();
 }
 
 void GpuBrowserCompositorOutputSurface::OnReflectorChanged() {
   if (!reflector_) {
     reflector_texture_.reset();
   } else {
     reflector_texture_.reset(new ReflectorTexture(context_provider()));
     reflector_->OnSourceTextureMailboxUpdated(reflector_texture_->mailbox());
   }
 }
 
-bool GpuBrowserCompositorOutputSurface::BindToClient(
+void GpuBrowserCompositorOutputSurface::BindToClient(
     cc::OutputSurfaceClient* client) {
-  if (!BrowserCompositorOutputSurface::BindToClient(client))
-    return false;
-
-  if (capabilities_.uses_default_gl_framebuffer) {
-    capabilities_.flipped_output_surface =
-        context_provider()->ContextCapabilities().flips_vertically;
-  }
+  DCHECK(client);
+  DCHECK(!client_);
+  client_ = client;
 
   GetCommandBufferProxy()->SetSwapBuffersCompletionCallback(
       base::Bind(&GpuBrowserCompositorOutputSurface::OnGpuSwapBuffersCompleted,
                  weak_ptr_factory_.GetWeakPtr()));
   GetCommandBufferProxy()->SetUpdateVSyncParametersCallback(base::Bind(
       &GpuBrowserCompositorOutputSurface::OnUpdateVSyncParametersFromGpu,
       weak_ptr_factory_.GetWeakPtr()));
-  return true;
 }
 
 void GpuBrowserCompositorOutputSurface::EnsureBackbuffer() {}
 
 void GpuBrowserCompositorOutputSurface::DiscardBackbuffer() {
   context_provider()->ContextGL()->DiscardBackbufferCHROMIUM();
 }
 
 void GpuBrowserCompositorOutputSurface::BindFramebuffer() {
   context_provider()->ContextGL()->BindFramebuffer(GL_FRAMEBUFFER, 0);
@@ skipping 57 matching lines @@
   ContextProviderCommandBuffer* provider_command_buffer =
       static_cast<content::ContextProviderCommandBuffer*>(
           context_provider_.get());
   gpu::CommandBufferProxyImpl* command_buffer_proxy =
       provider_command_buffer->GetCommandBufferProxy();
   DCHECK(command_buffer_proxy);
   return command_buffer_proxy;
 }
 
 }  // namespace content