Change exo::SurfaceFactoryOwner to exo::ExoCompositorFrameSink

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"
 #include "base/macros.h"
 #include "base/memory/ptr_util.h"
 #include "base/trace_event/trace_event.h"
 #include "base/trace_event/trace_event_argument.h"
 #include "cc/quads/render_pass.h"
 #include "cc/quads/shared_quad_state.h"
 #include "cc/quads/solid_color_draw_quad.h"
 #include "cc/quads/texture_draw_quad.h"
 #include "cc/resources/single_release_callback.h"
 #include "cc/surfaces/surface.h"
 #include "cc/surfaces/surface_factory.h"
 #include "cc/surfaces/surface_id_allocator.h"
 #include "cc/surfaces/surface_manager.h"
 #include "components/exo/buffer.h"
 #include "components/exo/surface_delegate.h"
 #include "components/exo/surface_observer.h"
+#include "mojo/public/cpp/bindings/strong_binding.h"
 #include "third_party/khronos/GLES2/gl2.h"
 #include "ui/aura/env.h"
 #include "ui/aura/window_delegate.h"
 #include "ui/aura/window_property.h"
 #include "ui/aura/window_targeter.h"
 #include "ui/base/cursor/cursor.h"
 #include "ui/base/hit_test.h"
 #include "ui/compositor/layer.h"
 #include "ui/events/event.h"
 #include "ui/gfx/buffer_format_util.h"
@@ skipping 118 matching lines @@
   if (!surface) {
     LOG(ERROR) << "Attempting to require callback on nonexistent surface";
     return;
   }
   surface->AddDestructionDependency(sequence);
 }
 
 }  // namespace
 
 ////////////////////////////////////////////////////////////////////////////////
-// SurfaceFactoryOwner, public:
-
-SurfaceFactoryOwner::SurfaceFactoryOwner() {}
-
-////////////////////////////////////////////////////////////////////////////////
-// cc::SurfaceFactoryClient overrides:
-
-void SurfaceFactoryOwner::ReturnResources(
-    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::LocalFrameId& id,
-                                          const gfx::Rect& damage_rect) {
-  if (surface_)
-    surface_->WillDraw();
-}
-
-void SurfaceFactoryOwner::SetBeginFrameSource(
-    cc::BeginFrameSource* begin_frame_source) {
-  if (surface_)
-    surface_->SetBeginFrameSource(begin_frame_source);
-}
-
-////////////////////////////////////////////////////////////////////////////////
-// SurfaceFactoryOwner, private:
-
-SurfaceFactoryOwner::~SurfaceFactoryOwner() {
-  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) {
+      surface_id_(
+          aura::Env::GetInstance()->context_factory()->AllocateFrameSinkId(),
+          cc::LocalFrameId()),
+      compositor_frame_sink_(new ExoCompositorFrameSink(
+          surface_id_.frame_sink_id(),
+          aura::Env::GetInstance()->context_factory()->GetSurfaceManager())) {
   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_ && needs_begin_frame_)
     begin_frame_source_->RemoveObserver(this);
-
-  if (local_frame_id_.is_valid())
-    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_);
+  return surface_id_;

[Fady Samuel, 2016/11/16 15:10:58]

I think what we might want to do here is *temporarily* make the current
"local_frame_id()" accessible from ExoCompositorFrameSink and combine that with
the fixed |frame_sink_id_| stored here. 

In the longer term, local_frame_id_s will be allocated by the client anyway so
we won't have this problem.

[Alex Z., 2016/11/16 19:56:16]

Done.

 }
 
 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>());
 }
 
@@ skipping 192 matching lines @@
 
   // 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::LocalFrameId old_local_frame_id = local_frame_id_;
-  if (needs_commit_to_new_surface_ || !local_frame_id_.is_valid()) {
-    needs_commit_to_new_surface_ = false;
-    local_frame_id_ = factory_owner_->id_allocator_->GenerateId();
-    factory_owner_->surface_factory_->Create(local_frame_id_);
-  }
-
   UpdateSurface(true);
 
-  if (old_local_frame_id.is_valid() && 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_local_frame_id != local_frame_id_) {
+  if (needs_commit_to_new_surface_) {
+    needs_commit_to_new_surface_ = false;
     float contents_surface_to_layer_scale = 1.0;
     // The bounds must be updated before switching to the new surface, because
     // the layer may be mirrored, in which case a surface change causes the
     // mirror layer to update its surface using the latest bounds.
     window_->layer()->SetBounds(
         gfx::Rect(window_->layer()->bounds().origin(), content_size_));
     window_->layer()->SetShowSurface(
-        cc::SurfaceId(factory_owner_->frame_sink_id_, local_frame_id_),
-        base::Bind(&SatisfyCallback, base::Unretained(surface_manager_)),
-        base::Bind(&RequireCallback, base::Unretained(surface_manager_)),
+        // TODO(staraz): use the new id created in compositor_frame_sink_
+        // instead
+        surface_id_,
+        base::Bind(&SatisfyCallback,
+                   base::Unretained(compositor_frame_sink_->surface_manager())),
+        base::Bind(&RequireCallback,
+                   base::Unretained(compositor_frame_sink_->surface_manager())),
         content_size_, contents_surface_to_layer_scale, content_size_);
     window_->layer()->SetFillsBoundsOpaquely(
         state_.blend_mode == SkXfermode::kSrc_Mode ||
         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));
+  DCHECK(
+      !current_resource_.id ||
+      compositor_frame_sink_->release_callbacks_.count(current_resource_.id));
 
   // 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;
@@ skipping 104 matching lines @@
   begin_frame_source_ = begin_frame_source;
   UpdateNeedsBeginFrame();
 }
 
 void Surface::CheckIfSurfaceHierarchyNeedsCommitToNewSurfaces() {
   if (HasLayerHierarchyChanged())
     SetSurfaceHierarchyNeedsCommitToNewSurfaces();
 }
 
 void Surface::OnLostResources() {
-  if (!local_frame_id_.is_valid())
+  if (!surface_id_.is_valid())
     return;
 
   UpdateResource(false);
   UpdateSurface(false);
 }
 
 void Surface::OnWindowAddedToRootWindow(aura::Window* window) {
   window->layer()->GetCompositor()->AddFrameSink(
-      factory_owner_->frame_sink_id_);
+      compositor_frame_sink_->frame_sink_id_);

[Fady Samuel, 2016/11/16 15:10:58]

The exo::Surface should have a fixed frame_sink_id allocated at creation. You
don't need to read it from the CompositorFrameSink.

[Alex Z., 2016/11/16 19:56:16]

Done.

 }
 
 void Surface::OnWindowRemovingFromRootWindow(aura::Window* window,
                                              aura::Window* new_root) {
   window->layer()->GetCompositor()->RemoveFrameSink(
-      factory_owner_->frame_sink_id_);
+      compositor_frame_sink_->frame_sink_id_);

[Fady Samuel, 2016/11/16 15:10:58]

The exo::Surface should have a fixed frame_sink_id allocated at creation. You
don't need to read it from the CompositorFrameSink.

[Alex Z., 2016/11/16 19:56:16]

Done.

 }
 
 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;
 }
 
@@ skipping 68 matching lines @@
 
   cc::TextureMailbox texture_mailbox;
   if (current_buffer_.buffer()) {
     texture_mailbox_release_callback =
         current_buffer_.buffer()->ProduceTextureMailbox(
             &texture_mailbox, state_.only_visible_on_secure_output,
             client_usage);
   }
 
   if (texture_mailbox_release_callback) {
     cc::TransferableResource resource;

[Fady Samuel, 2016/11/16 15:10:58]

I *think* what should happen is these resources should be part of the
resource_list in the CompositorFrame and then when SurfaceAggregator is done
when them then it should return the resources. +jbauman@ could better explain.

     resource.id = next_resource_id_++;
     resource.format = cc::RGBA_8888;
     resource.filter =
         texture_mailbox.nearest_neighbor() ? GL_NEAREST : GL_LINEAR;
     resource.size = texture_mailbox.size_in_pixels();
     resource.mailbox_holder = gpu::MailboxHolder(texture_mailbox.mailbox(),
                                                  texture_mailbox.sync_token(),
                                                  texture_mailbox.target());
     resource.is_overlay_candidate = texture_mailbox.is_overlay_candidate();
 
-    factory_owner_->release_callbacks_[resource.id] = std::make_pair(
-        factory_owner_, std::move(texture_mailbox_release_callback));
+    compositor_frame_sink_->release_callbacks_[resource.id] = std::make_pair(
+        compositor_frame_sink_, std::move(texture_mailbox_release_callback));
     current_resource_ = resource;
   } else {
     current_resource_.id = 0;
     current_resource_.size = gfx::Size();
   }
 }
 
 void Surface::UpdateSurface(bool full_damage) {
   gfx::Size buffer_size = current_resource_.size;
   gfx::SizeF scaled_buffer_size(
@@ skipping 72 matching lines @@
   } else {
     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(
-      local_frame_id_, std::move(frame), cc::SurfaceFactory::DrawCallback());
+  compositor_frame_sink_->SubmitCompositorFrame(std::move(frame));
 }
 
 void Surface::UpdateNeedsBeginFrame() {
   if (!begin_frame_source_)
     return;
 
   bool needs_begin_frame = !active_frame_callbacks_.empty();
   if (needs_begin_frame == needs_begin_frame_)
     return;
 
@@ skipping 24 matching lines @@
 
 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