Mozart: Improve tracing and backpressure.

services/gfx/compositor/graph/nodes.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 "services/gfx/compositor/graph/nodes.h"
 
 #include <ostream>
 
 #include "base/logging.h"
 #include "mojo/services/gfx/composition/cpp/formatting.h"
@@ skipping 177 matching lines @@
       return;
     }
 
     default: {
       NOTREACHED();
       return;
     }
   }
 }
 
-void Node::RecordPicture(const SceneContent* content,
-                         const Snapshot* snapshot,
-                         SkCanvas* canvas) const {
+void Node::Paint(const SceneContent* content,
+                 const Snapshot* snapshot,
+                 SkCanvas* canvas) const {
   DCHECK(content);
   DCHECK(snapshot);
   DCHECK(canvas);
 
   const bool must_save = content_transform_ || content_clip_;
   if (must_save) {
     canvas->save();
     if (content_transform_)
       canvas->concat(content_transform_->forward());
     if (content_clip_)
       canvas->clipRect(content_clip_->To<SkRect>());
   }
 
-  RecordPictureInner(content, snapshot, canvas);
+  PaintInner(content, snapshot, canvas);
 
   if (must_save)
     canvas->restore();
 }
 
-void Node::RecordPictureInner(const SceneContent* content,
-                              const Snapshot* snapshot,
-                              SkCanvas* canvas) const {
+void Node::PaintInner(const SceneContent* content,
+                      const Snapshot* snapshot,
+                      SkCanvas* canvas) const {
   DCHECK(content);
   DCHECK(snapshot);
   DCHECK(canvas);
 
   TraverseSnapshottedChildren(
       content, snapshot,
       [this, content, snapshot, canvas](const Node* child_node) -> bool {
-        child_node->RecordPicture(content, snapshot, canvas);
+        child_node->Paint(content, snapshot, canvas);
         return true;
       });
 }
 
 bool Node::HitTest(const SceneContent* content,
                    const Snapshot* snapshot,
                    const SkPoint& parent_point,
                    const SkMatrix44& global_to_parent_transform,
                    mojo::Array<mojo::gfx::composition::HitPtr>* hits) const {
   DCHECK(content);
@@ skipping 92 matching lines @@
            std::move(content_transform),
            content_clip.Pass(),
            hit_test_behavior.Pass(),
            combinator,
            child_node_ids),
       content_rect_(content_rect),
       color_(color) {}
 
 RectNode::~RectNode() {}
 
-void RectNode::RecordPictureInner(const SceneContent* content,
-                                  const Snapshot* snapshot,
-                                  SkCanvas* canvas) const {
+void RectNode::PaintInner(const SceneContent* content,
+                          const Snapshot* snapshot,
+                          SkCanvas* canvas) const {
   DCHECK(content);
   DCHECK(snapshot);
   DCHECK(canvas);
 
   SkPaint paint;
   paint.setColor(MakeSkColor(color_));
   canvas->drawRect(content_rect_.To<SkRect>(), paint);
 
-  Node::RecordPictureInner(content, snapshot, canvas);
+  Node::PaintInner(content, snapshot, canvas);
 }
 
 ImageNode::ImageNode(
     uint32_t node_id,
     std::unique_ptr<TransformPair> content_transform,
     mojo::RectFPtr content_clip,
     mojo::gfx::composition::HitTestBehaviorPtr hit_test_behavior,
     Combinator combinator,
     const std::vector<uint32_t>& child_node_ids,
     const mojo::RectF& content_rect,
@@ skipping 14 matching lines @@
 ImageNode::~ImageNode() {}
 
 bool ImageNode::RecordContent(SceneContentBuilder* builder) const {
   DCHECK(builder);
 
   return Node::RecordContent(builder) &&
          builder->RequireResource(image_resource_id_, Resource::Type::kImage,
                                   node_id());
 }
 
-void ImageNode::RecordPictureInner(const SceneContent* content,
-                                   const Snapshot* snapshot,
-                                   SkCanvas* canvas) const {
+void ImageNode::PaintInner(const SceneContent* content,
+                           const Snapshot* snapshot,
+                           SkCanvas* canvas) const {
   DCHECK(content);
   DCHECK(snapshot);
   DCHECK(canvas);
 
   auto image_resource = static_cast<const ImageResource*>(
       content->GetResource(image_resource_id_, Resource::Type::kImage));
   DCHECK(image_resource);
 
   SkPaint paint;
   SetPaintForBlend(&paint, blend_.get());
 
   canvas->drawImageRect(image_resource->image()->image().get(),
                         image_rect_
                             ? image_rect_->To<SkRect>()
                             : SkRect::MakeWH(image_resource->image()->width(),
                                              image_resource->image()->height()),
                         content_rect_.To<SkRect>(), &paint);
 
-  Node::RecordPictureInner(content, snapshot, canvas);
+  Node::PaintInner(content, snapshot, canvas);
 }
 
 SceneNode::SceneNode(
     uint32_t node_id,
     std::unique_ptr<TransformPair> content_transform,
     mojo::RectFPtr content_clip,
     mojo::gfx::composition::HitTestBehaviorPtr hit_test_behavior,
     Combinator combinator,
     const std::vector<uint32_t>& child_node_ids,
     uint32_t scene_resource_id,
@@ skipping 23 matching lines @@
   DCHECK(content);
   DCHECK(builder);
 
   Snapshot::Disposition disposition =
       builder->SnapshotReferencedScene(this, content);
   if (disposition != Snapshot::Disposition::kSuccess)
     return disposition;
   return Node::RecordSnapshot(content, builder);
 }
 
-void SceneNode::RecordPictureInner(const SceneContent* content,
-                                   const Snapshot* snapshot,
-                                   SkCanvas* canvas) const {
+void SceneNode::PaintInner(const SceneContent* content,
+                           const Snapshot* snapshot,
+                           SkCanvas* canvas) const {
   DCHECK(content);
   DCHECK(snapshot);
   DCHECK(canvas);
 
   const SceneContent* resolved_content =
       snapshot->GetResolvedSceneContent(this);
   DCHECK(resolved_content);
-  resolved_content->RecordPicture(snapshot, canvas);
+  resolved_content->Paint(snapshot, canvas);
 
-  Node::RecordPictureInner(content, snapshot, canvas);
+  Node::PaintInner(content, snapshot, canvas);
 }
 
 bool SceneNode::HitTestInner(
     const SceneContent* content,
     const Snapshot* snapshot,
     const SkPoint& local_point,
     const SkMatrix44& global_to_local_transform,
     mojo::Array<mojo::gfx::composition::HitPtr>* hits) const {
   DCHECK(content);
   DCHECK(snapshot);
@@ skipping 31 matching lines @@
            std::move(content_transform),
            content_clip.Pass(),
            hit_test_behavior.Pass(),
            combinator,
            child_node_ids),
       layer_rect_(layer_rect),
       blend_(blend.Pass()) {}
 
 LayerNode::~LayerNode() {}
 
-void LayerNode::RecordPictureInner(const SceneContent* content,
-                                   const Snapshot* snapshot,
-                                   SkCanvas* canvas) const {
+void LayerNode::PaintInner(const SceneContent* content,
+                           const Snapshot* snapshot,
+                           SkCanvas* canvas) const {
   DCHECK(content);
   DCHECK(snapshot);
   DCHECK(canvas);
 
   SkPaint paint;
   SetPaintForBlend(&paint, blend_.get());
 
   canvas->saveLayer(layer_rect_.To<SkRect>(), &paint);
-  Node::RecordPictureInner(content, snapshot, canvas);
+  Node::PaintInner(content, snapshot, canvas);
   canvas->restore();
 }
 
 }  // namespace compositor