ui: Move software fallback decisions to GpuProcessTransportFactory.

ui/compositor/compositor.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 "ui/compositor/compositor.h"
 
 #include <algorithm>
 #include <deque>
 
 #include "base/bind.h"
@@ skipping 58 matching lines @@
                        scoped_refptr<base::SingleThreadTaskRunner> task_runner)
     : context_factory_(context_factory),
       root_layer_(NULL),
       widget_(widget),
       surface_id_allocator_(context_factory->CreateSurfaceIdAllocator()),
       task_runner_(task_runner),
       vsync_manager_(new CompositorVSyncManager()),
       device_scale_factor_(0.0f),
       last_started_frame_(0),
       last_ended_frame_(0),
-      num_failed_recreate_attempts_(0),
       disable_schedule_composite_(false),
       compositor_lock_(NULL),
       layer_animator_collection_(this),
       weak_ptr_factory_(this) {
   root_web_layer_ = cc::Layer::Create();
 
   base::CommandLine* command_line = base::CommandLine::ForCurrentProcess();
 
   cc::LayerTreeSettings settings;
   // When impl-side painting is enabled, this will ensure PictureLayers always
@@ skipping 205 matching lines @@
 void Compositor::Layout() {
   // We're sending damage that will be addressed during this composite
   // cycle, so we don't need to schedule another composite to address it.
   disable_schedule_composite_ = true;
   if (root_layer_)
     root_layer_->SendDamagedRects();
   disable_schedule_composite_ = false;
 }
 
 void Compositor::RequestNewOutputSurface() {
-  bool fallback =
-      num_failed_recreate_attempts_ >= OUTPUT_SURFACE_RETRIES_BEFORE_FALLBACK;
-  context_factory_->CreateOutputSurface(weak_ptr_factory_.GetWeakPtr(),
-                                        fallback);
+  context_factory_->CreateOutputSurface(weak_ptr_factory_.GetWeakPtr());
 }
 
 void Compositor::DidInitializeOutputSurface() {
-  num_failed_recreate_attempts_ = 0;
 }
 
 void Compositor::DidFailToInitializeOutputSurface() {
-  num_failed_recreate_attempts_++;
-
-  // Tolerate a certain number of recreation failures to work around races
-  // in the output-surface-lost machinery.
-  if (num_failed_recreate_attempts_ >= MAX_OUTPUT_SURFACE_RETRIES)
-    LOG(FATAL) << "Failed to create a fallback OutputSurface.";
-
-  base::MessageLoop::current()->PostTask(
-      FROM_HERE, base::Bind(&Compositor::RequestNewOutputSurface,
-                            weak_ptr_factory_.GetWeakPtr()));
+  // The OutputSurface should already be bound/initialized before being given to
+  // the Compositor.
+  NOTREACHED();

[no sievers, 2015/02/25 01:51:00]

Although there is also |worker_context_provider_| being initialized in
OutputSurface::BindToClient() which could still fail.

Maybe we shouldn't make the assumption here about what else LTH(Impl)
initializes (or what GLRenderer does) that could fail and trigger this callback?

It would be a problem if it happens to create an infinite retry loop without
generating a crash report, I guess.

Should this maybe just also have a simple counter for successive attempts? (for
example reset in DidInitializeOutputSurface)

[enne (OOO), 2015/02/25 19:37:33]

I think it'd be fine to document that this can only be called if the output
surface fails to bind.  That's definitely the case right now.

[no sievers, 2015/02/25 20:52:12]

Sounds good then. I guess it is in the name :)

 }
 
 void Compositor::DidCommit() {
   DCHECK(!IsLocked());
   FOR_EACH_OBSERVER(CompositorObserver,
                     observer_list_,
                     OnCompositingDidCommit(this));
 }
 
 void Compositor::DidCommitAndDrawFrame() {
@@ skipping 48 matching lines @@
                     observer_list_,
                     OnCompositingLockStateChanged(this));
 }
 
 void Compositor::CancelCompositorLock() {
   if (compositor_lock_)
     compositor_lock_->CancelLock();
 }
 
 }  // namespace ui