Introducing SurfaceReferenceFactory

cc/surfaces/surface_manager.cc

 // 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.
 
 #include "cc/surfaces/surface_manager.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <utility>
 
 #include "base/logging.h"
 #include "cc/surfaces/surface.h"
 #include "cc/surfaces/surface_factory_client.h"
 #include "cc/surfaces/surface_id_allocator.h"
 
 namespace cc {
 
+namespace {
+
+class SurfaceRef final : public SurfaceRefWithSequence<SurfaceRef> {

[Saman Sami, 2016/11/30 18:05:52]

Move to a separate file and rename?

+ public:
+  SurfaceRef(SurfaceManager* manager,
+             const SurfaceId& surface_id,
+             float scale,
+             const gfx::Size& size);
+  // SurfaceRef(const SurfaceRef&);
+
+ protected:
+  void SatisfySequence(const SurfaceSequence&) override;
+  void RequireSequence(const SurfaceSequence&) override;
+
+ private:
+  SurfaceManager* manager_ = nullptr;
+};
+
+SurfaceRef::SurfaceRef(SurfaceManager* manager,
+                       const SurfaceId& surface_id,
+                       float scale,
+                       const gfx::Size& size)
+    : manager_(manager) {
+  SetMetadata(surface_id, scale, size);

[Fady Samuel, 2016/11/30 19:51:29]

Call the base class' constructor instead?

+}
+
+// SurfaceRef::SurfaceRef(const SurfaceRef& surface_ref) = default;
+
+void SurfaceRef::SatisfySequence(const SurfaceSequence& seq) {
+  std::vector<uint32_t> sequences;
+  sequences.push_back(seq.sequence);
+  manager_->DidSatisfySequences(seq.frame_sink_id, &sequences);
+}
+
+void SurfaceRef::RequireSequence(const SurfaceSequence& seq) {
+  auto surface = manager_->GetSurfaceForId(id());
+  if (!surface) {
+    LOG(ERROR) << "Attempting to require callback on nonexistent surface";
+    return;
+  }
+  surface->AddDestructionDependency(seq);
+}
+
+}  // namespace
+
 SurfaceManager::FrameSinkSourceMapping::FrameSinkSourceMapping()
     : client(nullptr), source(nullptr) {}
 
 SurfaceManager::FrameSinkSourceMapping::FrameSinkSourceMapping(
     const FrameSinkSourceMapping& other) = default;
 
 SurfaceManager::FrameSinkSourceMapping::~FrameSinkSourceMapping() {
   DCHECK(is_empty()) << "client: " << client
                      << ", children: " << children.size();
 }
@@ skipping 384 matching lines @@
   BeginFrameSource* parent_source = iter->second.source;
   if (!parent_source)
     return;
 
   // TODO(enne): these walks could be done in one step.
   RecursivelyDetachBeginFrameSource(child_frame_sink_id, parent_source);
   for (auto source_iter : registered_sources_)
     RecursivelyAttachBeginFrameSource(source_iter.second, source_iter.first);
 }
 
+SurfaceRefPtr SurfaceManager::NewSurfaceRef(const SurfaceId& surface_id,
+                                            float scale,
+                                            const gfx::Size& size) {
+  return SurfaceRefPtr(new SurfaceRef(this, surface_id, scale, size));
+}
+
 Surface* SurfaceManager::GetSurfaceForId(const SurfaceId& surface_id) {
   DCHECK(thread_checker_.CalledOnValidThread());
   SurfaceMap::iterator it = surface_map_.find(surface_id);
   if (it == surface_map_.end())
     return nullptr;
   return it->second;
 }
 
 bool SurfaceManager::SurfaceModified(const SurfaceId& surface_id) {
   CHECK(thread_checker_.CalledOnValidThread());
   bool changed = false;
   for (auto& observer : observer_list_)
     observer.OnSurfaceDamaged(surface_id, &changed);
   return changed;
 }
 
 void SurfaceManager::SurfaceCreated(const SurfaceId& surface_id,
                                     const gfx::Size& frame_size,
                                     float device_scale_factor) {
   CHECK(thread_checker_.CalledOnValidThread());
   for (auto& observer : observer_list_)
     observer.OnSurfaceCreated(surface_id, frame_size, device_scale_factor);
 }
 
 }  // namespace cc