ash: Low-latency laser pointer.

ash/laser/laser_pointer_view.h

 // Copyright 2016 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 ASH_LASER_LASER_POINTER_VIEW_H_
 #define ASH_LASER_LASER_POINTER_VIEW_H_
 
+#include <deque>
 #include <memory>
+#include <unordered_map>
 
 #include "ash/laser/laser_pointer_points.h"
 #include "base/macros.h"
+#include "base/memory/weak_ptr.h"
+#include "cc/resources/texture_mailbox.h"
+#include "cc/surfaces/compositor_frame_sink_support.h"
+#include "cc/surfaces/compositor_frame_sink_support_client.h"
+#include "cc/surfaces/local_surface_id_allocator.h"
 #include "ui/views/view.h"
 
 namespace aura {
 class Window;
 }
 
 namespace gfx {
+class GpuMemoryBuffer;
 class Point;
 }
 
 namespace views {
 class Widget;
 }
 
 namespace ash {
+struct LaserResource;
 
 // LaserPointerView displays the palette tool laser pointer. It draws the laser,
 // which consists of a point where the mouse cursor should be, as well as a
 // trail of lines to help users track.
-class LaserPointerView : public views::View {
+class LaserPointerView : public views::View,
+                         public cc::CompositorFrameSinkSupportClient {

[oshima, 2017/02/28 07:40:16]

This won't work in mus right? You may disable this for now, but please file a
bug to implement for mus.

Many cros-UI folks aren't familiar with compositor/HW overlay stuff, so brief
documentation + link/pointers would be helpful.

Maybe we should have a view class that does HW overlay?

[reveman, 2017/02/28 17:53:27]

I've updated the patch so it should now work with mus. Not sure how to verify
that though.
HW overlays shouldn't really matter here. This works without HW overlays and the
general concept is just to use a GpuMemoryBuffer backed surface for single
buffered output with minimal latency. It happens that on platforms with HW
overlay support this can result in very low latency.

The single buffered GpuMemoryBuffer usage here is unique and I don't think we'll
have other cases in Chrome OS UI where we're going to do something similar but
having some form of SurfaceView that handles the logic in UpdateSurface might be
nice. I'm going to leave the exercise of creating such a thing until we have
another use-case for it if that's OK? Exo is another use case but that's such a
special case as a result of how it needs to handle buffer release events that
I'm not sure it makes sense to share code there.

I'm going to document this type of single-buffered rendering on dev.chromium.org
once we have a real app (pepper3d or arc++) using it and we can then link to
that here.
https://docs.google.com/a/google.com/document/d/1HNfCZF7xxYL2KrYPKTUfm6XWfzjj...
is the best documentation we have until then.

  public:
   LaserPointerView(base::TimeDelta life_duration, aura::Window* root_window);
   ~LaserPointerView() override;
 
   void AddNewPoint(const gfx::Point& new_point);
   void UpdateTime();
   void Stop();
 
+  // Overridden from cc::CompositorFrameSinkSupportClient:
+  void DidReceiveCompositorFrameAck() override {}
+  void OnBeginFrame(const cc::BeginFrameArgs& args) override {}
+  void ReclaimResources(const cc::ReturnedResourceArray& resources) override;
+  void WillDrawSurface(const cc::LocalSurfaceId& local_surface_id,
+                       const gfx::Rect& damage_rect) override;
+
  private:
   friend class LaserPointerControllerTestApi;
 
-  // view::View:
-  void OnPaint(gfx::Canvas* canvas) override;
-
+  gfx::Rect GetBoundingBox();
   void OnPointsUpdated();
+  void UpdateBuffer();
+  void OnBufferUpdated();
+  void UpdateSurface();
+  void OnDidDrawSurface();
 
   LaserPointerPoints laser_points_;
   std::unique_ptr<views::Widget> widget_;
+  float scale_factor_ = 1.0f;
+  std::unique_ptr<gfx::GpuMemoryBuffer> gpu_memory_buffer_;
+  gfx::Rect buffer_damage_rect_;
+  bool pending_update_buffer_ = false;
+  gfx::Rect surface_damage_rect_;
+  bool needs_update_surface_ = false;
+  bool pending_draw_surface_ = false;
+  const cc::FrameSinkId frame_sink_id_;
+  cc::CompositorFrameSinkSupport frame_sink_support_;
+  cc::LocalSurfaceId local_surface_id_;
+  cc::LocalSurfaceIdAllocator id_allocator_;
+  int next_resource_id_ = 1;
+  std::unordered_map<int, std::unique_ptr<LaserResource>> resources_;
+  std::deque<std::unique_ptr<LaserResource>> returned_resources_;
+  base::WeakPtrFactory<LaserPointerView> weak_ptr_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(LaserPointerView);
 };
 
 }  // namespace ash
 
 #endif  // ASH_LASER_LASER_POINTER_VIEW_H_