Implement aura::Window::CreateCompositorFrameSink()

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/output/compositor_frame_sink.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/local_surface_id_allocator.h"
 #include "cc/surfaces/sequence_surface_reference_factory.h"
 #include "cc/surfaces/surface.h"
 #include "cc/surfaces/surface_manager.h"
 #include "components/exo/buffer.h"
 #include "components/exo/pointer.h"
 #include "components/exo/surface_delegate.h"
 #include "components/exo/surface_observer.h"
 #include "third_party/khronos/GLES2/gl2.h"
 #include "ui/aura/env.h"
 #include "ui/aura/window_delegate.h"
@@ skipping 128 matching lines @@
 
 }  // namespace
 
 ////////////////////////////////////////////////////////////////////////////////
 // Surface, public:
 
 // TODO(fsamuel): exo should not use context_factory_private. Instead, we should
 // request a CompositorFrameSink from the aura::Window. Setting up the
 // BeginFrame hierarchy should be an internal implementation detail of aura or
 // mus in aura-mus.
-Surface::Surface()
-    : window_(new aura::Window(new CustomWindowDelegate(this))),
-      frame_sink_id_(aura::Env::GetInstance()
-                         ->context_factory_private()
-                         ->AllocateFrameSinkId()) {
-  compositor_frame_sink_holder_ = new CompositorFrameSinkHolder(
-      this, frame_sink_id_,
-      aura::Env::GetInstance()->context_factory_private()->GetSurfaceManager());
-  // TODO(samans): exo::Surface should not be using
-  // DirectSurfaceReferenceFactory (crbug.com/688573).
-  surface_reference_factory_ = aura::Env::GetInstance()
-                                   ->context_factory_private()
-                                   ->GetSurfaceManager()
-                                   ->reference_factory();
+Surface::Surface() : window_(new aura::Window(new CustomWindowDelegate(this))) {
   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);
   aura::Env::GetInstance()->context_factory()->AddObserver(this);
+  compositor_frame_sink_holder_ = base::MakeUnique<CompositorFrameSinkHolder>(
+      this, window_->CreateCompositorFrameSink());
 }
 
 Surface::~Surface() {
   aura::Env::GetInstance()->context_factory()->RemoveObserver(this);
   for (SurfaceObserver& observer : observers_)
     observer.OnSurfaceDestroying(this);
 
   window_->RemoveObserver(this);
   if (window_->layer()->GetCompositor())
     window_->layer()->GetCompositor()->vsync_manager()->RemoveObserver(this);
@@ skipping 10 matching lines @@
   presentation_callbacks_.splice(presentation_callbacks_.end(),
                                  pending_presentation_callbacks_);
   swapping_presentation_callbacks_.splice(
       swapping_presentation_callbacks_.end(), presentation_callbacks_);
   swapped_presentation_callbacks_.splice(swapped_presentation_callbacks_.end(),
                                          swapping_presentation_callbacks_);
   // Call all presentation callbacks with a null presentation time to indicate
   // that they have been cancelled.
   for (const auto& presentation_callback : swapped_presentation_callbacks_)
     presentation_callback.Run(base::TimeTicks(), base::TimeDelta());
-
-  compositor_frame_sink_holder_->GetCompositorFrameSink()->EvictFrame();
 }
 
 // static
 Surface* Surface::AsSurface(const aura::Window* window) {
   return window->GetProperty(kSurfaceKey);
 }
 
 cc::SurfaceId Surface::GetSurfaceId() const {
-  return cc::SurfaceId(frame_sink_id_, local_surface_id_);
+  return window_->GetSurfaceId();
 }
 
 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 215 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::LocalSurfaceId old_local_surface_id = local_surface_id_;
-  if (needs_commit_to_new_surface_ || !local_surface_id_.is_valid()) {
-    needs_commit_to_new_surface_ = false;
-    local_surface_id_ = id_allocator_.GenerateId();
-  }
-
   // Move pending frame callbacks to the end of frame_callbacks_.
   frame_callbacks_.splice(frame_callbacks_.end(), pending_frame_callbacks_);
 
   // Move pending presentation callbacks to the end of presentation_callbacks_.
   presentation_callbacks_.splice(presentation_callbacks_.end(),
                                  pending_presentation_callbacks_);
 
   UpdateSurface(false);
 
-  if (old_local_surface_id != local_surface_id_) {
-    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_));
-    cc::SurfaceId surface_id(frame_sink_id_, local_surface_id_);
-    window_->layer()->SetShowPrimarySurface(
-        cc::SurfaceInfo(surface_id, contents_surface_to_layer_scale,
-                        content_size_),
-        surface_reference_factory_);
+  if (needs_commit_to_new_surface_) {
+    needs_commit_to_new_surface_ = false;
     window_->layer()->SetFillsBoundsOpaquely(
         !current_resource_has_alpha_ ||
         state_.blend_mode == SkBlendMode::kSrc ||
         state_.opaque_region.contains(
             gfx::RectToSkIRect(gfx::Rect(content_size_))));
   }
 
   // Reset damage.
   pending_damage_.setEmpty();
-
   DCHECK(!current_resource_.id ||
          compositor_frame_sink_holder_->HasReleaseCallbackForResource(
              current_resource_.id));
 
   // 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 142 matching lines @@
 
 void Surface::CheckIfSurfaceHierarchyNeedsCommitToNewSurfaces() {
   if (HasLayerHierarchyChanged())
     SetSurfaceHierarchyNeedsCommitToNewSurfaces();
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // ui::ContextFactoryObserver overrides:
 
 void Surface::OnLostResources() {
-  if (!local_surface_id_.is_valid())
+  if (!window_->GetSurfaceId().is_valid())
     return;
-
   UpdateResource(false);
   UpdateSurface(true);
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // aura::WindowObserver overrides:
 
 void Surface::OnWindowAddedToRootWindow(aura::Window* window) {
-  window->layer()->GetCompositor()->AddFrameSink(frame_sink_id_);
   window->layer()->GetCompositor()->vsync_manager()->AddObserver(this);
 }
 
 void Surface::OnWindowRemovingFromRootWindow(aura::Window* window,
                                              aura::Window* new_root) {
-  window->layer()->GetCompositor()->RemoveFrameSink(frame_sink_id_);
   window->layer()->GetCompositor()->vsync_manager()->RemoveObserver(this);
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // ui::CompositorVSyncManager::Observer overrides:
 
 void Surface::OnUpdateVSyncParameters(base::TimeTicks timebase,
                                       base::TimeDelta interval) {
   // Use current time if platform doesn't provide an accurate timebase.
   if (timebase.is_null())
@@ skipping 185 matching lines @@
       frame.resource_list.push_back(current_resource_);
     }
   } else {
     cc::SolidColorDrawQuad* solid_quad =
         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));
   compositor_frame_sink_holder_->GetCompositorFrameSink()
-      ->SubmitCompositorFrame(local_surface_id_, std::move(frame));
+      ->SubmitCompositorFrame(std::move(frame));
 }
 
 }  // namespace exo