cc: Introduce mechanism to observe CompositorFrames submitted to new surfaceIDs

cc/surfaces/surface_manager.h

 // 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.
 
 #ifndef CC_SURFACES_SURFACE_MANAGER_H_
 #define CC_SURFACES_SURFACE_MANAGER_H_
 
 #include <stdint.h>
 
 #include <list>
 #include <memory>
 #include <unordered_map>
 #include <unordered_set>
 #include <vector>
 
 #include "base/macros.h"
 #include "base/observer_list.h"
 #include "base/threading/thread_checker.h"
 #include "cc/surfaces/frame_sink_id.h"
-#include "cc/surfaces/surface_damage_observer.h"
 #include "cc/surfaces/surface_id.h"
+#include "cc/surfaces/surface_observer.h"
 #include "cc/surfaces/surface_sequence.h"
 #include "cc/surfaces/surfaces_export.h"
 
 namespace cc {
 class BeginFrameSource;
 class CompositorFrame;
 class Surface;
 class SurfaceFactoryClient;
 
 class CC_SURFACES_EXPORT SurfaceManager {
  public:
   SurfaceManager();
   ~SurfaceManager();
 
   void RegisterSurface(Surface* surface);
   void DeregisterSurface(const SurfaceId& surface_id);
 
   // Destroy the Surface once a set of sequence numbers has been satisfied.
   void Destroy(std::unique_ptr<Surface> surface);
 
   Surface* GetSurfaceForId(const SurfaceId& surface_id);
 
-  void AddObserver(SurfaceDamageObserver* obs) {
-    observer_list_.AddObserver(obs);
-  }
+  void AddObserver(SurfaceObserver* obs) { observer_list_.AddObserver(obs); }
 
-  void RemoveObserver(SurfaceDamageObserver* obs) {
+  void RemoveObserver(SurfaceObserver* obs) {
     observer_list_.RemoveObserver(obs);
   }
 
   bool SurfaceModified(const SurfaceId& surface_id);
 
+  // Called when a CompositorFrame is submitted to a SurfaceFactory for a given
+  // |surface_id| for the first time.
+  void SurfaceCreated(const SurfaceId& surface_id,
+                      const gfx::Size& frame_size,
+                      float device_scale_factor);
+
   // A frame for a surface satisfies a set of sequence numbers in a particular
   // id namespace.
   void DidSatisfySequences(const FrameSinkId& frame_sink_id,
                            std::vector<uint32_t>* sequence);
 
   void RegisterFrameSinkId(const FrameSinkId& frame_sink_id);
 
   // Invalidate a frame_sink_id that might still have associated sequences,
   // possibly because a renderer process has crashed.
   void InvalidateFrameSinkId(const FrameSinkId& frame_sink_id);
@@ skipping 39 matching lines @@
                                          BeginFrameSource* source);
   // Returns true if |child namespace| is or has |search_frame_sink_id| as a
   // child.
   bool ChildContains(const FrameSinkId& child_frame_sink_id,
                      const FrameSinkId& search_frame_sink_id) const;
 
   void GarbageCollectSurfaces();
 
   using SurfaceMap = std::unordered_map<SurfaceId, Surface*, SurfaceIdHash>;
   SurfaceMap surface_map_;
-  base::ObserverList<SurfaceDamageObserver> observer_list_;
+  base::ObserverList<SurfaceObserver> observer_list_;
   base::ThreadChecker thread_checker_;
 
   // List of surfaces to be destroyed, along with what sequences they're still
   // waiting on.
   using SurfaceDestroyList = std::list<std::unique_ptr<Surface>>;
   SurfaceDestroyList surfaces_to_destroy_;
 
   // Set of SurfaceSequences that have been satisfied by a frame but not yet
   // waited on.
   std::unordered_set<SurfaceSequence, SurfaceSequenceHash> satisfied_sequences_;
@@ skipping 23 matching lines @@
   // that is implicitly using this namespace must be reachable by the
   // parent in the dag.
   std::unordered_map<BeginFrameSource*, FrameSinkId> registered_sources_;
 
   DISALLOW_COPY_AND_ASSIGN(SurfaceManager);
 };
 
 }  // namespace cc
 
 #endif  // CC_SURFACES_SURFACE_MANAGER_H_