Introduce cc::LocalFrameId and use in SurfaceFactory

components/exo/surface.cc

 // Copyright 2015 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 "components/exo/surface.h"
 
 #include <utility>
 
 #include "base/callback_helpers.h"
 #include "base/logging.h"
@@ skipping 162 matching lines @@
     const cc::ReturnedResourceArray& resources) {
   scoped_refptr<SurfaceFactoryOwner> holder(this);
   for (auto& resource : resources) {
     auto it = release_callbacks_.find(resource.id);
     DCHECK(it != release_callbacks_.end());
     it->second.second->Run(resource.sync_token, resource.lost);
     release_callbacks_.erase(it);
   }
 }
 
-void SurfaceFactoryOwner::WillDrawSurface(const cc::SurfaceId& id,
+void SurfaceFactoryOwner::WillDrawSurface(const cc::LocalFrameId& id,
                                           const gfx::Rect& damage_rect) {
   if (surface_)
     surface_->WillDraw(id);
 }
 
 void SurfaceFactoryOwner::SetBeginFrameSource(
     cc::BeginFrameSource* begin_frame_source) {}
 
 ////////////////////////////////////////////////////////////////////////////////
 // SurfaceFactoryOwner, private:
@@ skipping 15 matching lines @@
   window_->SetType(ui::wm::WINDOW_TYPE_CONTROL);
   window_->SetName("ExoSurface");
   window_->SetProperty(kSurfaceKey, this);
   window_->Init(ui::LAYER_SOLID_COLOR);
   window_->set_layer_owner_delegate(this);
   window_->SetEventTargeter(base::WrapUnique(new CustomWindowTargeter));
   window_->set_owned_by_parent(false);
   factory_owner_->surface_ = this;
   factory_owner_->frame_sink_id_ =
       aura::Env::GetInstance()->context_factory()->AllocateFrameSinkId();
-  factory_owner_->id_allocator_.reset(
-      new cc::SurfaceIdAllocator(factory_owner_->frame_sink_id_));
+  factory_owner_->id_allocator_.reset(new cc::SurfaceIdAllocator());
   surface_manager_->RegisterFrameSinkId(factory_owner_->frame_sink_id_);
   factory_owner_->surface_factory_.reset(new cc::SurfaceFactory(
       factory_owner_->frame_sink_id_, surface_manager_, factory_owner_.get()));
   aura::Env::GetInstance()->context_factory()->AddObserver(this);
 }
 
 Surface::~Surface() {
   aura::Env::GetInstance()->context_factory()->RemoveObserver(this);
   FOR_EACH_OBSERVER(SurfaceObserver, observers_, OnSurfaceDestroying(this));
 
   window_->layer()->SetShowSolidColorContent();
 
   factory_owner_->surface_ = nullptr;
 
   // Call pending frame callbacks with a null frame time to indicate that they
   // have been cancelled.
   frame_callbacks_.splice(frame_callbacks_.end(), pending_frame_callbacks_);
   active_frame_callbacks_.splice(active_frame_callbacks_.end(),
                                  frame_callbacks_);
   for (const auto& frame_callback : active_frame_callbacks_)
     frame_callback.Run(base::TimeTicks());
 
-  if (!surface_id_.is_null())
-    factory_owner_->surface_factory_->Destroy(surface_id_);
+  if (!local_frame_id_.is_null())
+    factory_owner_->surface_factory_->Destroy(local_frame_id_);
 }
 
 // static
 Surface* Surface::AsSurface(const aura::Window* window) {
   return window->GetProperty(kSurfaceKey);
 }
 
+cc::SurfaceId Surface::GetSurfaceId() const {
+  return cc::SurfaceId(factory_owner_->frame_sink_id_, local_frame_id_);
+}
+
 void Surface::Attach(Buffer* buffer) {
   TRACE_EVENT1("exo", "Surface::Attach", "buffer",
                buffer ? buffer->GetSize().ToString() : "null");
 
   has_pending_contents_ = true;
   pending_buffer_.Reset(buffer ? buffer->AsWeakPtr() : base::WeakPtr<Buffer>());
 }
 
 void Surface::Damage(const gfx::Rect& damage) {
   TRACE_EVENT1("exo", "Surface::Damage", "damage", damage.ToString());
@@ skipping 174 matching lines @@
 
   if (delegate_) {
     delegate_->OnSurfaceCommit();
   } else {
     CheckIfSurfaceHierarchyNeedsCommitToNewSurfaces();
     CommitSurfaceHierarchy();
   }
 }
 
 void Surface::OnLostResources() {
-  if (surface_id_.is_null())
+  if (local_frame_id_.is_null())
     return;
 
   UpdateResource(false);
   UpdateSurface(false);
 }
 
 void Surface::CommitSurfaceHierarchy() {
   DCHECK(needs_commit_surface_hierarchy_);
   needs_commit_surface_hierarchy_ = false;
   has_pending_layer_changes_ = false;
 
   state_ = pending_state_;
   pending_state_.only_visible_on_secure_output = false;
 
   // We update contents if Attach() has been called since last commit.
   if (has_pending_contents_) {
     has_pending_contents_ = false;
 
     current_buffer_ = std::move(pending_buffer_);
 
     UpdateResource(true);
   }
 
-  cc::SurfaceId old_surface_id = surface_id_;
-  if (needs_commit_to_new_surface_ || surface_id_.is_null()) {
+  cc::LocalFrameId old_local_frame_id = local_frame_id_;
+  if (needs_commit_to_new_surface_ || local_frame_id_.is_null()) {
     needs_commit_to_new_surface_ = false;
-    surface_id_ = factory_owner_->id_allocator_->GenerateId();
-    factory_owner_->surface_factory_->Create(surface_id_);
+    local_frame_id_ = factory_owner_->id_allocator_->GenerateId();
+    factory_owner_->surface_factory_->Create(local_frame_id_);
   }
 
   UpdateSurface(true);
 
-  if (!old_surface_id.is_null() && old_surface_id != surface_id_) {
-    factory_owner_->surface_factory_->SetPreviousFrameSurface(surface_id_,
-                                                              old_surface_id);
-    factory_owner_->surface_factory_->Destroy(old_surface_id);
+  if (!old_local_frame_id.is_null() && old_local_frame_id != local_frame_id_) {
+    factory_owner_->surface_factory_->SetPreviousFrameSurface(
+        local_frame_id_, old_local_frame_id);
+    factory_owner_->surface_factory_->Destroy(old_local_frame_id);
   }
 
-  if (old_surface_id != surface_id_) {
+  if (old_local_frame_id != local_frame_id_) {
     float contents_surface_to_layer_scale = 1.0;
     window_->layer()->SetShowSurface(
-        surface_id_,
+        cc::SurfaceId(factory_owner_->frame_sink_id_, local_frame_id_),
         base::Bind(&SatisfyCallback, base::Unretained(surface_manager_)),
         base::Bind(&RequireCallback, base::Unretained(surface_manager_)),
         content_size_, contents_surface_to_layer_scale, content_size_);
     window_->layer()->SetBounds(
         gfx::Rect(window_->layer()->bounds().origin(), content_size_));
     window_->layer()->SetFillsBoundsOpaquely(
         state_.blend_mode == SkXfermode::kSrc_Mode ||
         state_.opaque_region.contains(
             gfx::RectToSkIRect(gfx::Rect(content_size_))));
   }
@@ skipping 111 matching lines @@
 // ui::LayerOwnerDelegate overrides:
 
 void Surface::OnLayerRecreated(ui::Layer* old_layer, ui::Layer* new_layer) {
   if (!current_buffer_.buffer())
     return;
 
   // TODO(reveman): Give the client a chance to provide new contents.
   SetSurfaceLayerContents(new_layer);
 }
 
-void Surface::WillDraw(const cc::SurfaceId& id) {
+void Surface::WillDraw(const cc::LocalFrameId& id) {
   while (!active_frame_callbacks_.empty()) {
     active_frame_callbacks_.front().Run(base::TimeTicks::Now());
     active_frame_callbacks_.pop_front();
   }
 }
 
 void Surface::CheckIfSurfaceHierarchyNeedsCommitToNewSurfaces() {
   if (HasLayerHierarchyChanged())
     SetSurfaceHierarchyNeedsCommitToNewSurfaces();
 }
@@ skipping 54 matching lines @@
 }
 
 void Surface::SetSurfaceHierarchyNeedsCommitToNewSurfaces() {
   needs_commit_to_new_surface_ = true;
   for (auto& sub_surface_entry : pending_sub_surfaces_) {
     sub_surface_entry.first->SetSurfaceHierarchyNeedsCommitToNewSurfaces();
   }
 }
 
 void Surface::SetSurfaceLayerContents(ui::Layer* layer) {
-  if (surface_id_.is_null())
+  if (local_frame_id_.is_null())
     return;
 
   gfx::Size layer_size = layer->bounds().size();
   float contents_surface_to_layer_scale = 1.0f;
 
   layer->SetShowSurface(
-      surface_id_,
+      cc::SurfaceId(factory_owner_->frame_sink_id_, local_frame_id_),
       base::Bind(&SatisfyCallback, base::Unretained(surface_manager_)),
       base::Bind(&RequireCallback, base::Unretained(surface_manager_)),
       layer_size, contents_surface_to_layer_scale, layer_size);
 }
 
 void Surface::UpdateResource(bool client_usage) {
   std::unique_ptr<cc::SingleReleaseCallback> texture_mailbox_release_callback;
 
   cc::TextureMailbox texture_mailbox;
   if (current_buffer_.buffer()) {
@@ skipping 103 matching lines @@
     cc::SolidColorDrawQuad* solid_quad =
         render_pass->CreateAndAppendDrawQuad<cc::SolidColorDrawQuad>();
     solid_quad->SetNew(quad_state, quad_rect, quad_rect, SK_ColorBLACK, false);
   }
 
   delegated_frame->render_pass_list.push_back(std::move(render_pass));
   cc::CompositorFrame frame;
   frame.delegated_frame_data = std::move(delegated_frame);
 
   factory_owner_->surface_factory_->SubmitCompositorFrame(
-      surface_id_, std::move(frame), cc::SurfaceFactory::DrawCallback());
+      local_frame_id_, std::move(frame), cc::SurfaceFactory::DrawCallback());
 }
 
 int64_t Surface::SetPropertyInternal(const void* key,
                                      const char* name,
                                      PropertyDeallocator deallocator,
                                      int64_t value,
                                      int64_t default_value) {
   int64_t old = GetPropertyInternal(key, default_value);
   if (value == default_value) {
     prop_map_.erase(key);
   } else {
     Value prop_value;
     prop_value.name = name;
     prop_value.value = value;
     prop_value.deallocator = deallocator;
     prop_map_[key] = prop_value;
   }
   return old;
 }
 
 int64_t Surface::GetPropertyInternal(const void* key,
                                      int64_t default_value) const {
   std::map<const void*, Value>::const_iterator iter = prop_map_.find(key);
   if (iter == prop_map_.end())
     return default_value;
   return iter->second.value;
 }
 
 }  // namespace exo