Re-land: cc: Implement shared worker contexts.

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 <set>
 #include <string>
@@ skipping 416 matching lines @@
   bool needs_full_tree_sync_;
   bool needs_meta_info_recomputation_;
 
   LayerTreeHostClient* client_;
   scoped_ptr<Proxy> proxy_;
 
   int source_frame_number_;
   int meta_information_sequence_number_;
   scoped_ptr<RenderingStatsInstrumentation> rendering_stats_instrumentation_;
 
+  // |current_output_surface_| can't be updated until we've successfully
+  // initialized a new output surface. |new_output_surface_| contains the
+  // new output surface that is currently being initialized. If initialization
+  // is successful then |new_output_surface_| replaces
+  // |current_output_surface_|.
+  scoped_ptr<OutputSurface> new_output_surface_;

[danakj, 2015/09/12 00:09:14]

+sievers: From what I can tell there's no good reason that LTH even owns these
after this, we could just have the embedders own the output surface entirely and
tell them when cc is done with it or something.

[reveman, 2015/09/12 12:49:57]

Sgtm but I think I prefer to save that for a follow up patch. Let me know if you
want me to add a TODO here.

[danakj, 2015/09/14 18:05:46]

Ya that's all I mean. No TODO is fine I think.

I also was thinking that if we made the RequestNewSurface pass back ownership of
the OS (ie make the LTHI pointer null at the time of loss, not at the time of
re-create-and-fail) then we could avoid having scoped_ptrs here on the LTH at
all, and just pass around ownership instead of "ok you can delete it now LTH"
more-or-less, which would be nice.

It changes when the LTHI::OS* pointer is null though, which might be a bit
tricky. Def not suggesting that here.

[no sievers, 2015/09/14 21:18:05]

Are you suggesting as a follow-up to move the ownership of the active OS back to
LTHI, but release (or return) it early on context lost so that we don't have to
track ownership of two surfaces?

Or are you saying that embedders should really 'own the output surface'
entirely, in which case we wouldn't pass ownership around? But that probably
isn't better, and we'd still need the same APIs to coordinate who is doing what
with it.

[danakj, 2015/09/14 21:22:47]

I was thinking the former. Documenting ownership/lifetime with scoped_ptr
passing is nice.

+  scoped_ptr<OutputSurface> current_output_surface_;
   bool output_surface_lost_;
 
   scoped_refptr<Layer> root_layer_;
   scoped_refptr<HeadsUpDisplayLayer> hud_layer_;
 
   base::WeakPtr<InputHandler> input_handler_weak_ptr_;
   base::WeakPtr<TopControlsManager> top_controls_manager_weak_ptr_;
 
   const LayerTreeSettings settings_;
   LayerTreeDebugState debug_state_;
@@ skipping 55 matching lines @@
 
   uint32_t surface_id_namespace_;
   uint32_t next_surface_sequence_;
 
   DISALLOW_COPY_AND_ASSIGN(LayerTreeHost);
 };
 
 }  // namespace cc
 
 #endif  // CC_TREES_LAYER_TREE_HOST_H_