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

cc/surfaces/display.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 "cc/surfaces/display.h"
 
 #include <stddef.h>
 
 #include "base/memory/ptr_util.h"
 #include "base/trace_event/trace_event.h"
@@ skipping 35 matching lines @@
       texture_mailbox_deleter_(std::move(texture_mailbox_deleter)) {
   DCHECK(output_surface_);
   DCHECK_EQ(!scheduler_, !begin_frame_source_);
   if (scheduler_)
     scheduler_->SetClient(this);
 }
 
 Display::~Display() {
   // Only do this if Initialize() happened.
   if (client_) {
+    if (auto* context = output_surface_->context_provider())
+      context->SetLostContextCallback(base::Closure());
     if (begin_frame_source_)
       surface_manager_->UnregisterBeginFrameSource(begin_frame_source_.get());
     surface_manager_->RemoveObserver(this);
   }
   if (aggregator_) {
     for (const auto& id_entry : aggregator_->previous_contained_surfaces()) {
       Surface* surface = surface_manager_->GetSurfaceForId(id_entry.first);
       if (surface)
         surface->RunDrawCallbacks();
     }
@@ skipping 11 matching lines @@
 
   surface_manager_->AddObserver(this);
 
   // This must be done in Initialize() so that the caller can delay this until
   // they are ready to receive a BeginFrameSource.
   if (begin_frame_source_) {
     surface_manager_->RegisterBeginFrameSource(begin_frame_source_.get(),
                                                frame_sink_id_);
   }
 
-  bool ok = output_surface_->BindToClient(this);
-  // The context given to the Display's OutputSurface should already be
-  // initialized, so Bind can not fail.
-  DCHECK(ok);
+  output_surface_->BindToClient(this);
   InitializeRenderer();
+
+  if (auto* context = output_surface_->context_provider()) {
+    // This depends on assumptions that Display::Initialize will happen
+    // on the same callstack as the ContextProvider being created/initialized
+    // or else it could miss a callback before setting this.
+    context->SetLostContextCallback(base::Bind(
+        &Display::DidLoseContextProvider,
+        // Unretained is safe since the callback is unset in this class'
+        // destructor and is never posted.
+        base::Unretained(this)));
+  }
 }
 
 void Display::SetSurfaceId(const SurfaceId& id, float device_scale_factor) {
   DCHECK(id.frame_sink_id() == frame_sink_id_);
   if (current_surface_id_ == id && device_scale_factor_ == device_scale_factor)
     return;
 
   TRACE_EVENT0("cc", "Display::SetSurfaceId");
   current_surface_id_ = id;
   device_scale_factor_ = device_scale_factor;
@@ skipping 93 matching lines @@
 
   // TODO(jbauman): Outputting an incomplete quad list doesn't work when using
   // overlays.
   bool output_partial_list = renderer_->use_partial_swap() &&
                              !output_surface_->GetOverlayCandidateValidator();
   aggregator_.reset(new SurfaceAggregator(
       surface_manager_, resource_provider_.get(), output_partial_list));
   aggregator_->set_output_is_secure(output_is_secure_);
 }
 
-void Display::DidLoseOutputSurface() {
-  if (scheduler_)
-    scheduler_->OutputSurfaceLost();
-  // WARNING: The client may delete the Display in this method call. Do not
-  // make any additional references to members after this call.
-  client_->DisplayOutputSurfaceLost();
-}
-
 void Display::UpdateRootSurfaceResourcesLocked() {
   Surface* surface = surface_manager_->GetSurfaceForId(current_surface_id_);
   bool root_surface_resources_locked =
       !surface || !surface->GetEligibleFrame().delegated_frame_data;
   if (scheduler_)
     scheduler_->SetRootSurfaceResourcesLocked(root_surface_resources_locked);
 }
 
+void Display::DidLoseContextProvider() {
+  if (scheduler_)
+    scheduler_->OutputSurfaceLost();
+  // WARNING: The client may delete the Display in this method call. Do not
+  // make any additional references to members after this call.
+  client_->DisplayOutputSurfaceLost();
+}
+
 bool Display::DrawAndSwap() {
   TRACE_EVENT0("cc", "Display::DrawAndSwap");
 
   if (current_surface_id_.is_null()) {
     TRACE_EVENT_INSTANT0("cc", "No root surface.", TRACE_EVENT_SCOPE_THREAD);
     return false;
   }
 
   if (!output_surface_) {
     TRACE_EVENT_INSTANT0("cc", "No output surface", TRACE_EVENT_SCOPE_THREAD);
@@ skipping 157 matching lines @@
 const SurfaceId& Display::CurrentSurfaceId() {
   return current_surface_id_;
 }
 
 void Display::ForceImmediateDrawAndSwapIfPossible() {
   if (scheduler_)
     scheduler_->ForceImmediateSwapIfPossible();
 }
 
 }  // namespace cc