1
    2
    3
    4
    5
    6
    7
    8
    9
   10
   11
   12
   13
   14
   15
   16
   17
   18
   19
   20
   21
   22
   23
   24
   25
   26
   27
   28
   29
   30
   31
   32
   33
   34
   35
   36
   37
   38
   39
   40
   41
   42
   43
   44
   45
   46
   47
   48
   49
   50
   51
   52
   53
   54
   55
   56
   57
   58
   59
   60
   61
   62
   63
   64
   65
   66
   67
   68
   69
   70
   71
   72
   73
   74
   75
   76
   77
   78
   79
   80
   81
   82
   83
   84
   85
   86
   87
   88
   89
   90
   91
   92
   93
   94
   95
   96
   97
   98
   99
  100
  101
  102
  103
  104
  105
  106
  107
  108
  109
  110
  111
  112
  113
  114
  115
  116
  117
  118
  119


ash / fast_ink / fast_ink_host.h [blame]

// Copyright 2017 The Chromium Authors
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

#ifndef ASH_FAST_INK_FAST_INK_HOST_H_
#define ASH_FAST_INK_FAST_INK_HOST_H_

#include <memory>
#include <vector>

#include "ash/ash_export.h"
#include "ash/frame_sink/frame_sink_host.h"
#include "base/memory/raw_ptr.h"
#include "ui/gfx/canvas.h"

namespace viz {
class CompositorFrame;
}  // namespace viz

namespace gfx {
class Rect;
}  // namespace gfx

namespace gpu {
class ClientSharedImage;
}

namespace ash {

// FastInkHost is used to support low-latency rendering. It supports
// 'auto-refresh' mode which provide minimum latency updates for the
// associated window. 'auto-refresh' mode will take advantage of HW overlays
// when possible and trigger continuous updates.
class ASH_EXPORT FastInkHost : public FrameSinkHost {
 public:
  // Provides flicker free painting to a mappable SharedImage.
  class ScopedPaint {
   public:
    ScopedPaint(const FastInkHost* host,
                const gfx::Rect& damage_rect_in_window);

    ScopedPaint(const ScopedPaint&) = delete;
    ScopedPaint& operator=(const ScopedPaint&) = delete;

    ~ScopedPaint();

    gfx::Canvas& canvas() { return canvas_; }

   private:
    const raw_ptr<FastInkHost> host_;

    // Damage rect in the buffer coordinates.
    gfx::Rect damage_rect_;
    gfx::Canvas canvas_;
  };

  FastInkHost();

  FastInkHost(const FastInkHost&) = delete;
  FastInkHost& operator=(const FastInkHost&) = delete;

  ~FastInkHost() override;

  std::unique_ptr<FastInkHost::ScopedPaint> CreateScopedPaint(
      const gfx::Rect& damage_rect_in_window) const;

  const gfx::Transform& window_to_buffer_transform() const {
    return window_to_buffer_transform_;
  }

  gpu::ClientSharedImage* client_si_for_test() const {
    return client_shared_image_.get();
  }

  int get_pending_bitmaps_size_for_test() const {
    return pending_bitmaps_.size();
  }

  // FrameSinkHost:
  void Init(aura::Window* host_window) override;
  void InitForTesting(aura::Window* host_window,
                      FrameSinkFactory frame_sink_factory) override;

 protected:
  // FrameSinkHost:
  std::unique_ptr<viz::CompositorFrame> CreateCompositorFrame(
      const viz::BeginFrameAck& begin_frame_ack,
      UiResourceManager& resource_manager,
      bool auto_update,
      const gfx::Size& last_submitted_frame_size,
      float last_submitted_frame_dsf) override;
  void OnFirstFrameRequested() override;

 private:
  void InitBufferMetadata(aura::Window* host_window);
  void InitializeFastInkBuffer(aura::Window* host_window);
  gfx::Rect BufferRectFromWindowRect(const gfx::Rect& rect_in_window) const;
  void Draw(SkBitmap bitmap, const gfx::Rect& damage_rect);
  void DrawBitmap(SkBitmap bitmap, const gfx::Rect& damage_rect);

  gfx::Transform window_to_buffer_transform_;

  gfx::Size buffer_size_;

  struct PendingBitmap {
    SkBitmap bitmap;
    gfx::Rect damage_rect;
  };

  std::vector<PendingBitmap> pending_bitmaps_;

  scoped_refptr<gpu::ClientSharedImage> client_shared_image_;
  gpu::SyncToken sync_token_;
  scoped_refptr<viz::RasterContextProvider> context_provider_;
};

}  // namespace ash

#endif  // ASH_FAST_INK_FAST_INK_HOST_H_