Get rid of some uses of base::Create*Value

cc/resources/tile_priority.cc

 // Copyright 2012 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/resources/tile_priority.h"
 
 #include "base/values.h"
 #include "cc/base/math_util.h"
 
 namespace {
@@ skipping 37 matching lines @@
     out->end_ = std::min(out->end_, t);
 }
 
 }  // namespace
 
 namespace cc {
 
 scoped_ptr<base::Value> WhichTreeAsValue(WhichTree tree) {
   switch (tree) {
   case ACTIVE_TREE:
-      return scoped_ptr<base::Value>(base::Value::CreateStringValue(
-          "ACTIVE_TREE"));
+      return scoped_ptr<base::Value>(new base::StringValue("ACTIVE_TREE"));
   case PENDING_TREE:
-      return scoped_ptr<base::Value>(base::Value::CreateStringValue(
-          "PENDING_TREE"));
+      return scoped_ptr<base::Value>(new base::StringValue("PENDING_TREE"));
   default:
       DCHECK(false) << "Unrecognized WhichTree value " << tree;
-      return scoped_ptr<base::Value>(base::Value::CreateStringValue(
+      return scoped_ptr<base::Value>(new base::StringValue(
           "<unknown WhichTree value>"));
   }
 }
 
 scoped_ptr<base::Value> TileResolutionAsValue(
     TileResolution resolution) {
   switch (resolution) {
   case LOW_RESOLUTION:
-    return scoped_ptr<base::Value>(base::Value::CreateStringValue(
-        "LOW_RESOLUTION"));
+    return scoped_ptr<base::Value>(new base::StringValue("LOW_RESOLUTION"));
   case HIGH_RESOLUTION:
-    return scoped_ptr<base::Value>(base::Value::CreateStringValue(
-        "HIGH_RESOLUTION"));
+    return scoped_ptr<base::Value>(new base::StringValue("HIGH_RESOLUTION"));
   case NON_IDEAL_RESOLUTION:
-      return scoped_ptr<base::Value>(base::Value::CreateStringValue(
+      return scoped_ptr<base::Value>(new base::StringValue(
         "NON_IDEAL_RESOLUTION"));
   }
   DCHECK(false) << "Unrecognized TileResolution value " << resolution;
-  return scoped_ptr<base::Value>(base::Value::CreateStringValue(
+  return scoped_ptr<base::Value>(new base::StringValue(
       "<unknown TileResolution value>"));
 }
 
 scoped_ptr<base::Value> TilePriority::AsValue() const {
   scoped_ptr<base::DictionaryValue> state(new base::DictionaryValue());
   state->Set("resolution", TileResolutionAsValue(resolution).release());
   state->Set("time_to_visible_in_seconds",
              MathUtil::AsValueSafely(time_to_visible_in_seconds).release());
   state->Set("distance_to_visible_in_pixels",
              MathUtil::AsValueSafely(distance_to_visible_in_pixels).release());
@@ skipping 36 matching lines @@
   IntersectNegativeHalfplane(
       &range, previous_bounds.bottom(), current_bounds.bottom(),
       target_bounds.y(), time_delta);
   return range.IsEmpty() ? kMaxTimeToVisibleInSeconds : range.start_;
 }
 
 scoped_ptr<base::Value> TileMemoryLimitPolicyAsValue(
     TileMemoryLimitPolicy policy) {
   switch (policy) {
   case ALLOW_NOTHING:
-      return scoped_ptr<base::Value>(base::Value::CreateStringValue(
-          "ALLOW_NOTHING"));
+      return scoped_ptr<base::Value>(new base::StringValue("ALLOW_NOTHING"));
   case ALLOW_ABSOLUTE_MINIMUM:
-      return scoped_ptr<base::Value>(base::Value::CreateStringValue(
+      return scoped_ptr<base::Value>(new base::StringValue(
           "ALLOW_ABSOLUTE_MINIMUM"));
   case ALLOW_PREPAINT_ONLY:
-      return scoped_ptr<base::Value>(base::Value::CreateStringValue(
+      return scoped_ptr<base::Value>(new base::StringValue(
           "ALLOW_PREPAINT_ONLY"));
   case ALLOW_ANYTHING:
-      return scoped_ptr<base::Value>(base::Value::CreateStringValue(
+      return scoped_ptr<base::Value>(new base::StringValue(
           "ALLOW_ANYTHING"));
   default:
       DCHECK(false) << "Unrecognized policy value";
-      return scoped_ptr<base::Value>(base::Value::CreateStringValue(
+      return scoped_ptr<base::Value>(new base::StringValue(
           "<unknown>"));
   }
 }
 
 scoped_ptr<base::Value> TreePriorityAsValue(TreePriority prio) {
   switch (prio) {
   case SAME_PRIORITY_FOR_BOTH_TREES:
-      return scoped_ptr<base::Value>(base::Value::CreateStringValue(
+      return scoped_ptr<base::Value>(new base::StringValue(
           "SAME_PRIORITY_FOR_BOTH_TREES"));
   case SMOOTHNESS_TAKES_PRIORITY:
-      return scoped_ptr<base::Value>(base::Value::CreateStringValue(
+      return scoped_ptr<base::Value>(new base::StringValue(
           "SMOOTHNESS_TAKES_PRIORITY"));
   case NEW_CONTENT_TAKES_PRIORITY:
-      return scoped_ptr<base::Value>(base::Value::CreateStringValue(
+      return scoped_ptr<base::Value>(new base::StringValue(
           "NEW_CONTENT_TAKES_PRIORITY"));
   }
   DCHECK(false) << "Unrecognized priority value " << prio;
-  return scoped_ptr<base::Value>(base::Value::CreateStringValue(
+  return scoped_ptr<base::Value>(new base::StringValue(
       "<unknown>"));
 }
 
 scoped_ptr<base::Value> GlobalStateThatImpactsTilePriority::AsValue() const {
   scoped_ptr<base::DictionaryValue> state(new base::DictionaryValue());
   state->Set("memory_limit_policy",
              TileMemoryLimitPolicyAsValue(memory_limit_policy).release());
   state->SetInteger("memory_limit_in_bytes", memory_limit_in_bytes);
   state->SetInteger("unused_memory_limit_in_bytes",
                     unused_memory_limit_in_bytes);
   state->SetInteger("num_resources_limit", num_resources_limit);
   state->Set("tree_priority", TreePriorityAsValue(tree_priority).release());
   return state.PassAs<base::Value>();
 }
 
 }  // namespace cc