cc: Defer first OutputSurface creation until client is ready

cc/trees/layer_tree_host.h

 // Copyright 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.
 
 #ifndef CC_TREES_LAYER_TREE_HOST_H_
 #define CC_TREES_LAYER_TREE_HOST_H_
 
 #include <limits>
 #include <list>
 #include <string>
@@ skipping 76 matching lines @@
       const LayerTreeSettings& settings,
       scoped_refptr<base::SingleThreadTaskRunner> impl_task_runner);
 
   static scoped_ptr<LayerTreeHost> CreateSingleThreaded(
       LayerTreeHostClient* client,
       LayerTreeHostSingleThreadClient* single_thread_client,
       SharedBitmapManager* manager,
       const LayerTreeSettings& settings);
   virtual ~LayerTreeHost();
 
-  void SetLayerTreeHostClientReady();
+  void SetLayerTreeHostClientReady(
+      scoped_ptr<OutputSurface> first_output_surface);

[jamesr, 2013/11/26 18:20:28]

hmm, why do you need this? we don't makecurrent() until the ready call. do you
need to create a different type of OutputSurface depending on what happens
pre-ready?

[no sievers, 2013/11/26 19:28:37]

I'm happy to try removing |first_output_surface| entirely too, and let the
scheduler trigger the creation through the client once it decides it's ready. Is
that what you are suggesting?

It'll have to go back to the main thread to get the surface, but doesn't seem
like that should be a problem.

[no sievers, 2013/11/26 22:19:57]

Also note odd behavior that I see in some of the browser tests which crash on
two broken assumptions with my patch:

- SetLayerTreeHostClientReady() is only called once: DCHECK(!client_ready_)

- Some browser_tests on linux_chromeos seem to fail the initial output surface
creation: DCHECK(first_output_surface) I added in
ThreadProxy::SetLayerTreeHostClientReady()

Removing first_output_surface simplifies things and keeps this working as
before.

 
   void set_needs_filter_context() { needs_filter_context_ = true; }
   bool needs_offscreen_context() const {
     return needs_filter_context_;
   }
 
   // LayerTreeHost interface to Proxy.
   void WillBeginMainFrame() {
     client_->WillBeginMainFrame(source_frame_number_);
   }
@@ skipping 175 matching lines @@
   int id() const { return tree_id_; }
 
   bool ScheduleMicroBenchmark(const std::string& benchmark_name,
                               scoped_ptr<base::Value> value,
                               const MicroBenchmark::DoneCallback& callback);
 
  protected:
   LayerTreeHost(LayerTreeHostClient* client,
                 SharedBitmapManager* manager,
                 const LayerTreeSettings& settings);
-  bool InitializeThreaded(
+  void InitializeThreaded(
       scoped_refptr<base::SingleThreadTaskRunner> impl_task_runner);
-  bool InitializeSingleThreaded(
+  void InitializeSingleThreaded(
       LayerTreeHostSingleThreadClient* single_thread_client);
-  bool InitializeForTesting(scoped_ptr<Proxy> proxy_for_testing);
+  void InitializeForTesting(scoped_ptr<Proxy> proxy_for_testing);
   void SetOutputSurfaceLostForTesting(bool is_lost) {
     output_surface_lost_ = is_lost;
   }
 
   MicroBenchmarkController micro_benchmark_controller_;
 
  private:
-  bool InitializeProxy(scoped_ptr<Proxy> proxy);
+  void InitializeProxy(scoped_ptr<Proxy> proxy);
 
   void PaintLayerContents(
       const RenderSurfaceLayerList& render_surface_layer_list,
       ResourceUpdateQueue* queue,
       bool* did_paint_content,
       bool* need_more_updates);
   void PaintMasksForRenderSurface(Layer* render_surface_layer,
                                   ResourceUpdateQueue* queue,
                                   bool* did_paint_content,
                                   bool* need_more_updates);
@@ skipping 33 matching lines @@
   bool needs_filter_context_;
 
   base::CancelableClosure prepaint_callback_;
 
   LayerTreeHostClient* client_;
   scoped_ptr<Proxy> proxy_;
 
   int source_frame_number_;
   scoped_ptr<RenderingStatsInstrumentation> rendering_stats_instrumentation_;
 
+  bool client_ready_;
   bool output_surface_can_be_initialized_;
   bool output_surface_lost_;
   int num_failed_recreate_attempts_;
 
   scoped_refptr<Layer> root_layer_;
   scoped_refptr<HeadsUpDisplayLayer> hud_layer_;
 
   scoped_ptr<PrioritizedResourceManager> contents_texture_manager_;
   scoped_ptr<PrioritizedResource> surface_memory_placeholder_;
 
@@ skipping 63 matching lines @@
   scoped_refptr<Layer> outer_viewport_scroll_layer_;
 
   SharedBitmapManager* shared_bitmap_manager_;
 
   DISALLOW_COPY_AND_ASSIGN(LayerTreeHost);
 };
 
 }  // namespace cc
 
 #endif  // CC_TREES_LAYER_TREE_HOST_H_