c/b/extensions, json_schema_compiler: Do not use Value::Create*.

chrome/browser/extensions/api/serial/serial_api.cc

 // Copyright (c) 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 "chrome/browser/extensions/api/serial/serial_api.h"
 
 #include "base/values.h"
 #include "chrome/browser/extensions/extension_system.h"
 #include "chrome/browser/extensions/api/serial/serial_connection.h"
 #include "chrome/browser/extensions/api/serial/serial_port_enumerator.h"
@@ skipping 47 matching lines @@
 }
 
 void SerialGetPortsFunction::Work() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
 
   base::ListValue* ports = new base::ListValue();
   SerialPortEnumerator::StringSet port_names =
       SerialPortEnumerator::GenerateValidSerialPortNames();
   SerialPortEnumerator::StringSet::const_iterator i = port_names.begin();
   while (i != port_names.end()) {
-    ports->Append(Value::CreateStringValue(*i++));
+    ports->Append(new base::StringValue(*i++));
   }
 
   SetResult(ports);
 }
 
 bool SerialGetPortsFunction::Respond() {
   return true;
 }
 
 // It's a fool's errand to come up with a default bitrate, because we don't get
@@ skipping 96 matching lines @@
 void SerialCloseFunction::Work() {
   bool close_result = false;
   SerialConnection* serial_connection = GetSerialConnection(
       params_->connection_id);
   if (serial_connection) {
     serial_connection->Close();
     RemoveSerialConnection(params_->connection_id);
     close_result = true;
   }
 
-  SetResult(Value::CreateBooleanValue(close_result));
+  SetResult(new base::FundamentalValue(close_result));
 }
 
 bool SerialCloseFunction::Respond() {
   return true;
 }
 
 SerialReadFunction::SerialReadFunction() {
 }
 
 SerialReadFunction::~SerialReadFunction() {
@@ skipping 91 matching lines @@
 
 void SerialFlushFunction::Work() {
   bool flush_result = false;
   SerialConnection* serial_connection = GetSerialConnection(
       params_->connection_id);
   if (serial_connection) {
     serial_connection->Flush();
     flush_result = true;
   }
 
-  SetResult(Value::CreateBooleanValue(flush_result));
+  SetResult(new base::FundamentalValue(flush_result));
 }
 
 bool SerialFlushFunction::Respond() {
   return true;
 }
 
 SerialGetControlSignalsFunction::SerialGetControlSignalsFunction()
     : api_response_(false) {
 }
 
@@ skipping 54 matching lines @@
       params_->connection_id);
   if (serial_connection) {
     SerialConnection::ControlSignals control_signals = { 0 };
     control_signals.should_set_dtr = params_->options.dtr.get() != NULL;
     if (control_signals.should_set_dtr)
       control_signals.dtr = *(params_->options.dtr);
     control_signals.should_set_rts = params_->options.rts.get() != NULL;
     if (control_signals.should_set_rts)
       control_signals.rts = *(params_->options.rts);
     if (serial_connection->SetControlSignals(control_signals)) {
-      SetResult(Value::CreateBooleanValue(true));
+      SetResult(new base::FundamentalValue(true));
     } else {
       error_ = kErrorSetControlSignalsFailed;
-      SetResult(Value::CreateBooleanValue(false));
+      SetResult(new base::FundamentalValue(false));
     }
   } else {
     error_ = kSerialConnectionNotFoundError;
-    SetResult(Value::CreateBooleanValue(false));
+    SetResult(new base::FundamentalValue(false));
   }
 }
 
 bool SerialSetControlSignalsFunction::Respond() {
   return true;
 }
 
 }  // namespace extensions