Introducing SurfaceReferenceFactory

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/sequence_surface_reference_factory.h"
 #include "cc/surfaces/surface.h"
 #include "cc/surfaces/surface_id_allocator.h"
 #include "components/exo/buffer.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"
 #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"
 #include "ui/gfx/geometry/safe_integer_conversions.h"
 #include "ui/gfx/geometry/size_conversions.h"
 #include "ui/gfx/gpu_memory_buffer.h"
 #include "ui/gfx/path.h"
 #include "ui/gfx/skia_util.h"
 #include "ui/gfx/transform_util.h"
 #include "ui/views/widget/widget.h"
 
 DECLARE_WINDOW_PROPERTY_TYPE(exo::Surface*);
 
 namespace exo {
 namespace {
 
+class SurfaceReferenceFactory : public cc::SequenceSurfaceReferenceFactory {

[reveman, 2016/12/15 19:59:58]

Please move this below the CustomWindowTargeter class. How about
SurfaceReferenceFactoryImpl? or follow the pattern below and call it
CustomSurfaceReferenceFactory.

[Saman Sami, 2016/12/15 20:41:37]

Done.

+ public:
+  explicit SurfaceReferenceFactory(
+      scoped_refptr<CompositorFrameSinkHolder> sink_holder)

[reveman, 2016/12/15 19:59:58]

s/scoped_refptr<CompositorFrameSinkHolder>/CompositorFrameSinkHolder */ and
remove std::move below

[Saman Sami, 2016/12/15 20:41:37]

Done.

+      : sink_holder_(std::move(sink_holder)) {}
+
+ private:
+  ~SurfaceReferenceFactory() override = default;
+
+  // cc::SequenceSurfaceReferenceFactory implementation:

[reveman, 2016/12/15 19:59:58]

nit: "// Overridden from cc::SequenceSurfaceReferenceFactory:" for consistency

[Saman Sami, 2016/12/15 20:41:37]

Done.

+  void SatisfySequence(const cc::SurfaceSequence& sequence) const override {
+    sink_holder_->Satisfy(sequence);
+  }
+
+  void RequireSequence(const cc::SurfaceId& surface_id,
+                       const cc::SurfaceSequence& sequence) const override {
+    sink_holder_->Require(surface_id, sequence);
+  }
+
+  scoped_refptr<CompositorFrameSinkHolder> sink_holder_;
+
+  DISALLOW_COPY_AND_ASSIGN(SurfaceReferenceFactory);
+};
+
 // A property key containing the surface that is associated with
 // window. If unset, no surface is associated with window.
 DEFINE_WINDOW_PROPERTY_KEY(Surface*, kSurfaceKey, nullptr);
 
 // Helper function that returns an iterator to the first entry in |list|
 // with |key|.
 template <typename T, typename U>
 typename T::iterator FindListEntry(T& list, U key) {
   return std::find_if(list.begin(), list.end(),
                       [key](const typename T::value_type& entry) {
@@ skipping 97 matching lines @@
                          ->AllocateFrameSinkId()) {
   cc::mojom::MojoCompositorFrameSinkClientPtr frame_sink_holder_ptr;
   cc::mojom::MojoCompositorFrameSinkClientRequest frame_sink_client_request =
       mojo::GetProxy(&frame_sink_holder_ptr);
   std::unique_ptr<CompositorFrameSink> frame_sink(new CompositorFrameSink(
       frame_sink_id_,
       aura::Env::GetInstance()->context_factory_private()->GetSurfaceManager(),
       std::move(frame_sink_holder_ptr)));
   compositor_frame_sink_holder_ = new CompositorFrameSinkHolder(
       this, std::move(frame_sink), std::move(frame_sink_client_request));
+  ref_factory_ = new SurfaceReferenceFactory(compositor_frame_sink_holder_);
   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);
 }
 
@@ skipping 240 matching lines @@
 
   UpdateSurface(false);
 
   if (old_local_frame_id != local_frame_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_frame_id_);
     window_->layer()->SetShowSurface(
-        cc::SurfaceId(frame_sink_id_, local_frame_id_),
-        base::Bind(&CompositorFrameSinkHolder::Satisfy,
-                   compositor_frame_sink_holder_),
-        base::Bind(&CompositorFrameSinkHolder::Require,
-                   compositor_frame_sink_holder_),
-        content_size_, contents_surface_to_layer_scale);
+        cc::SurfaceInfo(surface_id, contents_surface_to_layer_scale,
+                        content_size_),
+        ref_factory_);
     window_->layer()->SetFillsBoundsOpaquely(
         state_.blend_mode == SkBlendMode::kSrc ||
         state_.opaque_region.contains(
             gfx::RectToSkIRect(gfx::Rect(content_size_))));
   }
 
   // Reset damage.
   pending_damage_.setEmpty();
 
   DCHECK(!current_resource_.id ||
@@ skipping 328 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