Implement aura::Window::CreateCompositorFrameSink()

cc/output/compositor_frame_sink.h

 // Copyright 2012 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.
 
 #ifndef CC_OUTPUT_COMPOSITOR_FRAME_SINK_H_
 #define CC_OUTPUT_COMPOSITOR_FRAME_SINK_H_
 
 #include <deque>
 #include <memory>
 
 #include "base/macros.h"
 #include "base/memory/ref_counted.h"
 #include "base/threading/thread_checker.h"
 #include "cc/cc_export.h"
 #include "cc/output/context_provider.h"
 #include "cc/output/overlay_candidate_validator.h"
 #include "cc/output/vulkan_context_provider.h"
 #include "cc/resources/returned_resource.h"
+#include "cc/surfaces/surface_id.h"
 #include "gpu/command_buffer/common/texture_in_use_response.h"
 #include "ui/gfx/color_space.h"
 
 namespace gpu {
 class GpuMemoryBufferManager;
 }
 
 namespace cc {
 
 class CompositorFrame;
@@ skipping 85 matching lines @@
   //
   // CompositorFrameSink::Invalidate is called by the compositor to notify that
   // there's new content.
   virtual void Invalidate() {}
 
   // For successful swaps, the implementation must call
   // DidReceiveCompositorFrameAck() asynchronously when the frame has been
   // processed in order to unthrottle the next frame.
   virtual void SubmitCompositorFrame(CompositorFrame frame) = 0;
 
+  // Notify that the surface is no longer in use (and is okay to be evicted) so
+  // that its resources gets returned in time.
+  virtual void EvictFrame() {}

[piman, 2017/05/08 20:30:15]

What calls this?

[Peng, 2017/05/08 20:41:49]

exo::Surface::~Surface() calls it to flush frames. But the
cc::CompositorFrameSink until will be alive until all resources are returned via
cc::CompositorFrameSinkClient::ReclaimResources(). So evicting frames in
cc::CompositorFrameSink::DetachFromClient or dtor doesn't work.

[piman, 2017/05/08 23:18:03]

cc::CompositorFrameSink is the API that LayerTreeHostImpl uses to interact with
its client. I don't think we should be adding this, as LTHI doesn't call it.
In particular you've implemented this function for many subclasses, but they
will never be called.

I'm not sure why exo::Surface needs a cc::CompositorFrameSink - it didn't
before. It doesn't have a compositor to give it to. It seems an odd fit.

Did you mean to use a MojoCompositorFrameSink instead, maybe?

[Peng, 2017/05/09 17:26:57]

I removed this method. And call support_->EvictFrame() in DetachFromClient().
Done

+
  protected:
   // Bound to the ContextProvider to hear about when it is lost and inform the
   // |client_|.
   void DidLoseCompositorFrameSink();
 
   CompositorFrameSinkClient* client_ = nullptr;
 
   struct CompositorFrameSink::Capabilities capabilities_;
   scoped_refptr<ContextProvider> context_provider_;
   scoped_refptr<ContextProvider> worker_context_provider_;
   scoped_refptr<VulkanContextProvider> vulkan_context_provider_;
   gpu::GpuMemoryBufferManager* gpu_memory_buffer_manager_;
   SharedBitmapManager* shared_bitmap_manager_;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(CompositorFrameSink);
 };
 
 }  // namespace cc
 
 #endif  // CC_OUTPUT_COMPOSITOR_FRAME_SINK_H_