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


cc / view_transition / view_transition_request.h [blame]

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

#ifndef CC_VIEW_TRANSITION_VIEW_TRANSITION_REQUEST_H_
#define CC_VIEW_TRANSITION_VIEW_TRANSITION_REQUEST_H_

#include <map>
#include <memory>
#include <string>
#include <utility>
#include <vector>

#include "base/functional/callback.h"
#include "cc/cc_export.h"
#include "components/viz/common/quads/compositor_frame_transition_directive.h"
#include "components/viz/common/quads/compositor_render_pass.h"
#include "components/viz/common/view_transition_element_resource_id.h"
#include "third_party/blink/public/common/tokens/tokens.h"
#include "ui/gfx/display_color_spaces.h"

namespace cc {

// This class represents a view transition request. It is constructed in
// Blink with an intent of translating this request into a viz directive for the
// transition to occur.
class CC_EXPORT ViewTransitionRequest {
 public:
  using ViewTransitionElementMap =
      std::map<viz::ViewTransitionElementResourceId,
               viz::CompositorRenderPassId>;
  using Type = viz::CompositorFrameTransitionDirective::Type;

  using ViewTransitionContentRectMap = viz::ViewTransitionElementResourceRects;
  using ViewTransitionCaptureCallback =
      base::OnceCallback<void(const ViewTransitionContentRectMap&)>;
  // Creates a Type::kCapture type of request.
  // `transition_token` is an identifier that uniquely identifies each
  // transition.
  // `maybe_cross_frame_sink` is set if this transition can start and animate on
  // different CompositorFrameSink instances (i.e. cross-document navigations).
  static std::unique_ptr<ViewTransitionRequest> CreateCapture(
      const blink::ViewTransitionToken& transition_token,
      bool maybe_cross_frame_sink,
      std::vector<viz::ViewTransitionElementResourceId> capture_ids,
      ViewTransitionCaptureCallback commit_callback);

  // Creates a Type::kAnimateRenderer type of request.
  static std::unique_ptr<ViewTransitionRequest> CreateAnimateRenderer(
      const blink::ViewTransitionToken& transition_token,
      bool maybe_cross_frame_sink);

  // Creates a Type::kRelease type of request.
  static std::unique_ptr<ViewTransitionRequest> CreateRelease(
      const blink::ViewTransitionToken& transition_token,
      bool maybe_cross_frame_sink);

  ViewTransitionRequest(ViewTransitionRequest&) = delete;
  ~ViewTransitionRequest();

  ViewTransitionRequest& operator=(ViewTransitionRequest&) = delete;

  // The callback is run when the request is sufficiently processed for us to be
  // able to begin the next step in the animation. In other words, when this
  // callback is invoked it can resolve a script promise that is gating this
  // step.
  ViewTransitionCaptureCallback TakeFinishedCallback() {
    return std::move(commit_callback_);
  }

  // This constructs a viz directive. Note that repeated calls to this function
  // would create a new sequence id for the directive, which means it would be
  // processed again by viz.
  viz::CompositorFrameTransitionDirective ConstructDirective(
      const ViewTransitionElementMap& shared_element_render_pass_id_map,
      const gfx::DisplayColorSpaces& display_color_spaces) const;

  // Returns the sequence id for this request.
  uint32_t sequence_id() const { return sequence_id_; }

  Type type() const { return type_; }

  // Testing / debugging functionality.
  std::string ToString() const;

  const blink::ViewTransitionToken& token() { return transition_token_; }

 private:
  ViewTransitionRequest(
      Type type,
      const blink::ViewTransitionToken& transition_token,
      bool maybe_cross_frame_sink,
      std::vector<viz::ViewTransitionElementResourceId> capture_ids,
      ViewTransitionCaptureCallback commit_callback);

  const Type type_;
  const blink::ViewTransitionToken transition_token_;
  const bool maybe_cross_frame_sink_;
  ViewTransitionCaptureCallback commit_callback_;
  const uint32_t sequence_id_;
  const std::vector<viz::ViewTransitionElementResourceId> capture_resource_ids_;

  static uint32_t s_next_sequence_id_;
};

}  // namespace cc

#endif  // CC_VIEW_TRANSITION_VIEW_TRANSITION_REQUEST_H_