exo: Recreate Surface resources on context lost.

ui/compositor/compositor.h

 // 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.
 
 #ifndef UI_COMPOSITOR_COMPOSITOR_H_
 #define UI_COMPOSITOR_COMPOSITOR_H_
 
 #include <stdint.h>
 
 #include <memory>
@@ skipping 51 matching lines @@
 
 class Compositor;
 class CompositorVSyncManager;
 class LatencyInfo;
 class Layer;
 class Reflector;
 class Texture;
 
 const int kCompositorLockTimeoutMs = 67;
 
+class COMPOSITOR_EXPORT ContextFactoryObserver {
+ public:
+  virtual ~ContextFactoryObserver() {}
+
+  // Notifies that the ContextProvider returned from
+  // ui::ContextFactory::SharedMainThreadContextProvider was lost.  When this
+  // is called, the old resources (e.g. shared context, GL helper) still
+  // exist, but are about to be destroyed. Getting a reference to those
+  // resources from the ContextFactory (e.g. through
+  // SharedMainThreadContextProvider()) will return newly recreated, valid
+  // resources.
+  virtual void OnLostResources() = 0;
+};
+
 // This class abstracts the creation of the 3D context for the compositor. It is
 // a global object.
 class COMPOSITOR_EXPORT ContextFactory {
  public:
-  virtual ~ContextFactory() {}
+  virtual ~ContextFactory();
 
   // Creates an output surface for the given compositor. The factory may keep
   // per-compositor data (e.g. a shared context), that needs to be cleaned up
   // by calling RemoveCompositor when the compositor gets destroyed.
   virtual void CreateOutputSurface(base::WeakPtr<Compositor> compositor) = 0;
 
   // Creates a reflector that copies the content of the |mirrored_compositor|
   // onto |mirroring_layer|.
   virtual std::unique_ptr<Reflector> CreateReflector(
       Compositor* mirrored_compositor,
@@ skipping 34 matching lines @@
   virtual cc::SurfaceManager* GetSurfaceManager() = 0;
 
   // Resize the display corresponding to this compositor to a particular size.
   virtual void ResizeDisplay(ui::Compositor* compositor,
                              const gfx::Size& size) = 0;
 
   virtual void SetAuthoritativeVSyncInterval(ui::Compositor* compositor,
                                              base::TimeDelta interval) = 0;
 
   virtual void SetOutputIsSecure(Compositor* compositor, bool secure) = 0;
+
+  void AddObserver(ContextFactoryObserver* observer);
+
+  void RemoveObserver(ContextFactoryObserver* observer);
+
+ protected:
+  ContextFactory();
+  base::ObserverList<ContextFactoryObserver> observer_list_;

[piman, 2016/06/21 01:14:13]

Can we keep this class pure virtual? I realize you're trying to save code, but
because we need multiple inheritance, we should stick to pure interfaces.

 };
 
 // This class represents a lock on the compositor, that can be used to prevent
 // commits to the compositor tree while we're waiting for an asynchronous
 // event. The typical use case is when waiting for a renderer to produce a frame
 // at the right size. The caller keeps a reference on this object, and drops the
 // reference once it desires to release the lock.
 // By default, the lock will be cancelled after a short timeout to ensure
 // responsiveness of the UI, so the compositor tree should be kept in a
 // "reasonable" state while the lock is held. If the compositor sets
@@ skipping 235 matching lines @@
   scoped_refptr<cc::AnimationTimeline> animation_timeline_;
 
   base::WeakPtrFactory<Compositor> weak_ptr_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(Compositor);
 };
 
 }  // namespace ui
 
 #endif  // UI_COMPOSITOR_COMPOSITOR_H_