Reverse scene node drawing order.

services/gfx/compositor/graph/node_def.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/node_def.h"
 
 #include "base/logging.h"
 #include "base/strings/stringprintf.h"
 #include "mojo/services/gfx/composition/cpp/formatting.h"
 #include "mojo/skia/type_converters.h"
@@ skipping 173 matching lines @@
 RectNodeOp::RectNodeOp(const mojo::Rect& content_rect,
                        const mojo::gfx::composition::Color& color)
     : content_rect_(content_rect), color_(color) {}
 
 RectNodeOp::~RectNodeOp() {}
 
 bool RectNodeOp::Snapshot(SnapshotBuilder* snapshot_builder,
                           RenderLayerBuilder* layer_builder,
                           SceneDef* scene,
                           NodeDef* node) {
-  if (!node->SnapshotChildren(snapshot_builder, layer_builder, scene))
-    return false;
-
   SkPaint paint;
   paint.setColor(MakeSkColor(color_));
   layer_builder->DrawRect(content_rect_.To<SkRect>(), paint);
-  return true;
+
+  return node->SnapshotChildren(snapshot_builder, layer_builder, scene);
 }
 
 ImageNodeOp::ImageNodeOp(const mojo::Rect& content_rect,
                          mojo::RectPtr image_rect,
                          uint32 image_resource_id,
                          mojo::gfx::composition::BlendPtr blend)
     : content_rect_(content_rect),
       image_rect_(image_rect.Pass()),
       image_resource_id_(image_resource_id),
       blend_(blend.Pass()) {}
@@ skipping 20 matching lines @@
   if (!image_resource_->image()) {
     if (snapshot_builder->block_log()) {
       *snapshot_builder->block_log()
           << "Node blocked due to its referenced image "
              "resource being unavailable: "
           << node->FormattedLabel(scene) << std::endl;
     }
     return false;
   }
 
-  if (!node->SnapshotChildren(snapshot_builder, layer_builder, scene))
-    return false;
-
   layer_builder->DrawImage(
       image_resource_->image(), content_rect_.To<SkRect>(),
       image_rect_ ? image_rect_->To<SkRect>()
                   : SkRect::MakeWH(image_resource_->image()->width(),
                                    image_resource_->image()->height()),
       blend_ ? MakePaintForBlend(*blend_) : SkPaint());
-  return true;
+
+  return node->SnapshotChildren(snapshot_builder, layer_builder, scene);
 }
 
 SceneNodeOp::SceneNodeOp(uint32_t scene_resource_id, uint32_t scene_version)
     : scene_resource_id_(scene_resource_id), scene_version_(scene_version) {}
 
 SceneNodeOp::~SceneNodeOp() {}
 
 bool SceneNodeOp::Validate(SceneDef* scene, NodeDef* node, std::ostream& err) {
   scene_resource_ = scene->FindSceneResource(scene_resource_id_);
   if (!scene_resource_) {
@@ skipping 30 matching lines @@
       *snapshot_builder->block_log()
           << "Node blocked due to its referenced scene "
              "resource not having the desired version: "
           << node->FormattedLabel(scene)
           << ", requested_version=" << scene_version_
           << ", actual_version=" << actual_version << std::endl;
     }
     return false;
   }
 
-  if (!node->SnapshotChildren(snapshot_builder, layer_builder, scene))
+  if (!referenced_scene->Snapshot(snapshot_builder, layer_builder))
     return false;
 
-  return referenced_scene->Snapshot(snapshot_builder, layer_builder);
+  return node->SnapshotChildren(snapshot_builder, layer_builder, scene);
 }
 
 LayerNodeOp::LayerNodeOp(const mojo::Size& size,
                          mojo::gfx::composition::BlendPtr blend)
     : size_(size), blend_(blend.Pass()) {}
 
 LayerNodeOp::~LayerNodeOp() {}
 
 bool LayerNodeOp::Snapshot(SnapshotBuilder* snapshot_builder,
                            RenderLayerBuilder* layer_builder,
                            SceneDef* scene,
                            NodeDef* node) {
   SkRect content_rect = SkRect::MakeWH(size_.width, size_.height);
   RenderLayerBuilder children_layer_builder(&content_rect);
   if (!node->SnapshotChildren(snapshot_builder, &children_layer_builder, scene))
     return false;
 
   layer_builder->DrawSavedLayer(
       children_layer_builder.Build(), content_rect,
       blend_ ? MakePaintForBlend(*blend_) : SkPaint());
   return true;
 }
 
 }  // namespace compositor