exo: Connect frame callbacks with UI compositor begin frames.

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 165 matching lines @@
     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::LocalFrameId& id,
                                           const gfx::Rect& damage_rect) {
   if (surface_)
-    surface_->WillDraw(id);
+    surface_->WillDraw();
 }
 
 void SurfaceFactoryOwner::SetBeginFrameSource(
-    cc::BeginFrameSource* begin_frame_source) {}
+    cc::BeginFrameSource* begin_frame_source) {
+  if (surface_)
+    surface_->SetBeginFrameSource(begin_frame_source);
+}
 
 ////////////////////////////////////////////////////////////////////////////////
 // SurfaceFactoryOwner, private:
 
 SurfaceFactoryOwner::~SurfaceFactoryOwner() {
-  if (surface_factory_->manager()) {
+  if (surface_factory_->manager())
     surface_factory_->manager()->InvalidateFrameSinkId(frame_sink_id_);
-  }
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // Surface, public:
 
 Surface::Surface()
     : window_(new aura::Window(new CustomWindowDelegate(this))),
       surface_manager_(
           aura::Env::GetInstance()->context_factory()->GetSurfaceManager()),
       factory_owner_(new SurfaceFactoryOwner) {
   window_->SetType(ui::wm::WINDOW_TYPE_CONTROL);
   window_->SetName("ExoSurface");
   window_->SetProperty(kSurfaceKey, this);
   window_->Init(ui::LAYER_SOLID_COLOR);
   window_->SetEventTargeter(base::WrapUnique(new CustomWindowTargeter));
   window_->set_owned_by_parent(false);
+  window_->AddObserver(this);
   factory_owner_->surface_ = this;
   factory_owner_->frame_sink_id_ =
       aura::Env::GetInstance()->context_factory()->AllocateFrameSinkId();
   factory_owner_->id_allocator_.reset(new cc::SurfaceIdAllocator());
   surface_manager_->RegisterFrameSinkId(factory_owner_->frame_sink_id_);
+  surface_manager_->RegisterSurfaceFactoryClient(factory_owner_->frame_sink_id_,
+                                                 factory_owner_.get());
   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 (SurfaceObserver& observer : observers_)
     observer.OnSurfaceDestroying(this);
 
+  window_->RemoveObserver(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 (begin_frame_source_)
+    begin_frame_source_->RemoveObserver(this);
+
   if (!local_frame_id_.is_null())
     factory_owner_->surface_factory_->Destroy(local_frame_id_);
+
+  surface_manager_->UnregisterSurfaceFactoryClient(
+      factory_owner_->frame_sink_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_);
 }
@@ skipping 184 matching lines @@
   }
 
   if (delegate_) {
     delegate_->OnSurfaceCommit();
   } else {
     CheckIfSurfaceHierarchyNeedsCommitToNewSurfaces();
     CommitSurfaceHierarchy();
   }
 }
 
-void Surface::OnLostResources() {
-  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_) {
@@ skipping 36 matching lines @@
         state_.opaque_region.contains(
             gfx::RectToSkIRect(gfx::Rect(content_size_))));
   }
 
   // Reset damage.
   pending_damage_.setEmpty();
 
   DCHECK(!current_resource_.id ||
          factory_owner_->release_callbacks_.count(current_resource_.id));
 
-  // Move pending frame callbacks to the end of active_frame_callbacks_
-  active_frame_callbacks_.splice(active_frame_callbacks_.end(),
-                                 pending_frame_callbacks_);
+  // Move pending frame callbacks to the end of frame_callbacks_.
+  frame_callbacks_.splice(frame_callbacks_.end(), pending_frame_callbacks_);
 
   // Synchronize window hierarchy. This will position and update the stacking
   // order of all sub-surfaces after committing all pending state of sub-surface
   // descendants.
   aura::Window* stacking_target = nullptr;
   for (auto& sub_surface_entry : pending_sub_surfaces_) {
     Surface* sub_surface = sub_surface_entry.first;
 
     // Synchronsouly commit all pending state of the sub-surface and its
     // decendents.
@@ skipping 80 matching lines @@
   return observers_.HasObserver(observer);
 }
 
 std::unique_ptr<base::trace_event::TracedValue> Surface::AsTracedValue() const {
   std::unique_ptr<base::trace_event::TracedValue> value(
       new base::trace_event::TracedValue());
   value->SetString("name", window_->layer()->name());
   return value;
 }
 
-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::WillDraw() {
+  active_frame_callbacks_.splice(active_frame_callbacks_.end(),
+                                 frame_callbacks_);
+  UpdateNeedsBeginFrame();
+}
+
+void Surface::SetBeginFrameSource(cc::BeginFrameSource* begin_frame_source) {
+  begin_frame_source_ = begin_frame_source;
+  UpdateNeedsBeginFrame();
 }
 
 void Surface::CheckIfSurfaceHierarchyNeedsCommitToNewSurfaces() {
   if (HasLayerHierarchyChanged())
     SetSurfaceHierarchyNeedsCommitToNewSurfaces();
 }
 
+void Surface::OnLostResources() {
+  if (local_frame_id_.is_null())
+    return;
+
+  UpdateResource(false);
+  UpdateSurface(false);
+}
+
+void Surface::OnWindowAddedToRootWindow(aura::Window* window) {
+  window->layer()->GetCompositor()->AddFrameSink(
+      factory_owner_->frame_sink_id_);
+}
+
+void Surface::OnWindowRemovingFromRootWindow(aura::Window* window,
+                                             aura::Window* new_root) {
+  window->layer()->GetCompositor()->RemoveFrameSink(
+      factory_owner_->frame_sink_id_);
+}
+
+void Surface::OnBeginFrame(const cc::BeginFrameArgs& args) {
+  while (!active_frame_callbacks_.empty()) {
+    active_frame_callbacks_.front().Run(args.frame_time);
+    active_frame_callbacks_.pop_front();
+  }
+  last_begin_frame_args_ = args;
+}
+
+const cc::BeginFrameArgs& Surface::LastUsedBeginFrameArgs() const {
+  return last_begin_frame_args_;
+}
+
 Surface::State::State() : input_region(SkIRect::MakeLargest()) {}
 
 Surface::State::~State() = default;
 
 bool Surface::State::operator==(const State& other) {
   return (other.crop == crop && alpha == other.alpha &&
           other.blend_mode == blend_mode && other.viewport == viewport &&
           other.opaque_region == opaque_region &&
           other.buffer_scale == buffer_scale &&
           other.input_region == input_region);
@@ skipping 160 matching lines @@
         render_pass->CreateAndAppendDrawQuad<cc::SolidColorDrawQuad>();
     solid_quad->SetNew(quad_state, quad_rect, quad_rect, SK_ColorBLACK, false);
   }
 
   frame.render_pass_list.push_back(std::move(render_pass));
 
   factory_owner_->surface_factory_->SubmitCompositorFrame(
       local_frame_id_, std::move(frame), cc::SurfaceFactory::DrawCallback());
 }
 
+void Surface::UpdateNeedsBeginFrame() {
+  if (!begin_frame_source_) {
+    needs_begin_frame_ = false;
+    return;
+  }
+
+  bool needs_begin_frame = !active_frame_callbacks_.empty();
+  if (needs_begin_frame == needs_begin_frame_)
+    return;
+
+  needs_begin_frame_ = needs_begin_frame;
+  if (needs_begin_frame)
+    begin_frame_source_->AddObserver(this);
+  else
+    begin_frame_source_->RemoveObserver(this);
+}
+
 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