CC: Plumb LayerSettings parameter for cc::Layer construction.

cc/test/layer_tree_json_parser.cc

 // Copyright 2013 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 "cc/test/layer_tree_json_parser.h"
 
 #include "base/test/values_test_util.h"
 #include "base/values.h"
 #include "cc/layers/content_layer.h"
 #include "cc/layers/layer.h"
 #include "cc/layers/nine_patch_layer.h"
 #include "cc/layers/picture_layer.h"
 #include "cc/layers/solid_color_layer.h"
 #include "cc/layers/texture_layer.h"
+#include "cc/trees/layer_tree_settings.h"
 
 namespace cc {
 
 namespace {
 
 scoped_refptr<Layer> ParseTreeFromValue(base::Value* val,
                                         ContentLayerClient* content_client) {
   base::DictionaryValue* dict;
   bool success = true;
   success &= val->GetAsDictionary(&dict);
   std::string layer_type;
   success &= dict->GetString("LayerType", &layer_type);
   base::ListValue* list;
   success &= dict->GetList("Bounds", &list);
   int width, height;
   success &= list->GetInteger(0, &width);
   success &= list->GetInteger(1, &height);
   success &= dict->GetList("Position", &list);
   double position_x, position_y;
   success &= list->GetDouble(0, &position_x);
   success &= list->GetDouble(1, &position_y);
 
   bool draws_content;
   success &= dict->GetBoolean("DrawsContent", &draws_content);
 
+  LayerSettings layer_settings;
+
   scoped_refptr<Layer> new_layer;
   if (layer_type == "SolidColorLayer") {
-    new_layer = SolidColorLayer::Create();
+    new_layer = SolidColorLayer::Create(layer_settings);
   } else if (layer_type == "ContentLayer") {
-    new_layer = ContentLayer::Create(content_client);
+    new_layer = ContentLayer::Create(layer_settings, content_client);
   } else if (layer_type == "NinePatchLayer") {
     success &= dict->GetList("ImageAperture", &list);
     int aperture_x, aperture_y, aperture_width, aperture_height;
     success &= list->GetInteger(0, &aperture_x);
     success &= list->GetInteger(1, &aperture_y);
     success &= list->GetInteger(2, &aperture_width);
     success &= list->GetInteger(3, &aperture_height);
 
     base::ListValue* bounds;
     success &= dict->GetList("ImageBounds", &bounds);
     double image_width, image_height;
     success &= bounds->GetDouble(0, &image_width);
     success &= bounds->GetDouble(1, &image_height);
 
     success &= dict->GetList("Border", &list);
     int border_x, border_y, border_width, border_height;
     success &= list->GetInteger(0, &border_x);
     success &= list->GetInteger(1, &border_y);
     success &= list->GetInteger(2, &border_width);
     success &= list->GetInteger(3, &border_height);
 
     bool fill_center;
     success &= dict->GetBoolean("FillCenter", &fill_center);
 
-    scoped_refptr<NinePatchLayer> nine_patch_layer = NinePatchLayer::Create();
+    scoped_refptr<NinePatchLayer> nine_patch_layer =
+        NinePatchLayer::Create(layer_settings);
 
     SkBitmap bitmap;
     bitmap.allocN32Pixels(image_width, image_height);
     bitmap.setImmutable();
     nine_patch_layer->SetBitmap(bitmap);
     nine_patch_layer->SetAperture(
         gfx::Rect(aperture_x, aperture_y, aperture_width, aperture_height));
     nine_patch_layer->SetBorder(
         gfx::Rect(border_x, border_y, border_width, border_height));
     nine_patch_layer->SetFillCenter(fill_center);
 
     new_layer = nine_patch_layer;
   } else if (layer_type == "TextureLayer") {
-    new_layer = TextureLayer::CreateForMailbox(NULL);
+    new_layer = TextureLayer::CreateForMailbox(layer_settings, NULL);
   } else if (layer_type == "PictureLayer") {
-    new_layer = PictureLayer::Create(content_client);
+    new_layer = PictureLayer::Create(layer_settings, content_client);
   } else {  // Type "Layer" or "unknown"
-    new_layer = Layer::Create();
+    new_layer = Layer::Create(layer_settings);
   }
   new_layer->SetPosition(gfx::PointF(position_x, position_y));
   new_layer->SetBounds(gfx::Size(width, height));
   new_layer->SetIsDrawable(draws_content);
 
   double opacity;
   if (dict->GetDouble("Opacity", &opacity))
     new_layer->SetOpacity(opacity);
 
   bool contents_opaque;
@@ skipping 91 matching lines @@
 
 }  // namespace
 
 scoped_refptr<Layer> ParseTreeFromJson(std::string json,
                                        ContentLayerClient* content_client) {
   scoped_ptr<base::Value> val = base::test::ParseJson(json);
   return ParseTreeFromValue(val.get(), content_client);
 }
 
 }  // namespace cc