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

chrome/browser/extensions/api/notifications/notifications_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/notifications/notifications_api.h"
 
 #include "base/callback.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/time/time.h"
@@ skipping 131 matching lines @@
 
   virtual void Display() OVERRIDE { }
 
   virtual void Error() OVERRIDE {
     scoped_ptr<base::ListValue> args(CreateBaseEventArgs());
     SendEvent(event_names::kOnNotificationError, args.Pass());
   }
 
   virtual void Close(bool by_user) OVERRIDE {
     scoped_ptr<base::ListValue> args(CreateBaseEventArgs());
-    args->Append(Value::CreateBooleanValue(by_user));
+    args->Append(new base::FundamentalValue(by_user));
     SendEvent(event_names::kOnNotificationClosed, args.Pass());
   }
 
   virtual void Click() OVERRIDE {
     scoped_ptr<base::ListValue> args(CreateBaseEventArgs());
     SendEvent(event_names::kOnNotificationClicked, args.Pass());
   }
 
   virtual bool HasClickedListener() OVERRIDE {
     return ExtensionSystem::Get(profile_)->event_router()->HasEventListener(
         event_names::kOnNotificationClicked);
   }
 
   virtual void ButtonClick(int index) OVERRIDE {
     scoped_ptr<base::ListValue> args(CreateBaseEventArgs());
-    args->Append(Value::CreateIntegerValue(index));
+    args->Append(new base::FundamentalValue(index));
     SendEvent(event_names::kOnNotificationButtonClicked, args.Pass());
   }
 
   virtual std::string id() const OVERRIDE {
     return scoped_id_;
   }
 
   virtual int process_id() const OVERRIDE {
     return process_id_;
   }
@@ skipping 16 matching lines @@
   virtual ~NotificationsApiDelegate() {}
 
   void SendEvent(const std::string& name, scoped_ptr<base::ListValue> args) {
     scoped_ptr<Event> event(new Event(name, args.Pass()));
     ExtensionSystem::Get(profile_)->event_router()->DispatchEventToExtension(
         extension_id_, event.Pass());
   }
 
   scoped_ptr<base::ListValue> CreateBaseEventArgs() {
     scoped_ptr<base::ListValue> args(new base::ListValue());
-    args->Append(Value::CreateStringValue(id_));
+    args->Append(new base::StringValue(id_));
     return args.Pass();
   }
 
   scoped_refptr<ApiFunction> api_function_;
   Profile* profile_;
   const std::string extension_id_;
   const std::string id_;
   const std::string scoped_id_;
   int process_id_;
 
@@ skipping 268 matching lines @@
   // arbitrary "extension.api.999" notificationIds that will collide with
   // future generated IDs. It doesn't seem necessary to try to prevent this; if
   // developers want to hurt themselves, we'll let them.
   const std::string extension_id(extension_->id());
   std::string notification_id;
   if (!params_->notification_id.empty())
     notification_id = params_->notification_id;
   else
     notification_id = kNotificationPrefix + base::Uint64ToString(next_id_++);
 
-  SetResult(Value::CreateStringValue(notification_id));
+  SetResult(new base::StringValue(notification_id));
 
   // TODO(dewittj): Add more human-readable error strings if this fails.
   if (!CreateNotification(notification_id, &params_->options))
     return false;
 
   SendResponse(true);
 
   return true;
 }
 
 NotificationsUpdateFunction::NotificationsUpdateFunction() {
 }
 
 NotificationsUpdateFunction::~NotificationsUpdateFunction() {
 }
 
 bool NotificationsUpdateFunction::RunNotificationsApi() {
   params_ = api::notifications::Update::Params::Create(*args_);
   EXTENSION_FUNCTION_VALIDATE(params_.get());
 
   // We are in update.  If the ID doesn't exist, succeed but call the callback
   // with "false".
   const Notification* matched_notification =
       g_browser_process->notification_ui_manager()->FindById(
           CreateScopedIdentifier(extension_->id(), params_->notification_id));
   if (!matched_notification) {
-    SetResult(Value::CreateBooleanValue(false));
+    SetResult(new base::FundamentalValue(false));
     SendResponse(true);
     return true;
   }
 
   // If we have trouble updating the notification (could be improper use of API
   // or some other reason), mark the function as failed, calling the callback
   // with false.
   // TODO(dewittj): Add more human-readable error strings if this fails.
   Notification notification = *matched_notification;
   bool could_update_notification = UpdateNotification(
       params_->notification_id, &params_->options, &notification);
-  SetResult(Value::CreateBooleanValue(could_update_notification));
+  SetResult(new base::FundamentalValue(could_update_notification));
   if (!could_update_notification)
     return false;
 
   // No trouble, created the notification, send true to the callback and
   // succeed.
   SendResponse(true);
   return true;
 }
 
 NotificationsClearFunction::NotificationsClearFunction() {
 }
 
 NotificationsClearFunction::~NotificationsClearFunction() {
 }
 
 bool NotificationsClearFunction::RunNotificationsApi() {
   params_ = api::notifications::Clear::Params::Create(*args_);
   EXTENSION_FUNCTION_VALIDATE(params_.get());
 
   bool cancel_result = g_browser_process->notification_ui_manager()->CancelById(
       CreateScopedIdentifier(extension_->id(), params_->notification_id));
 
-  SetResult(Value::CreateBooleanValue(cancel_result));
+  SetResult(new base::FundamentalValue(cancel_result));
   SendResponse(true);
 
   return true;
 }
 
 NotificationsGetAllFunction::NotificationsGetAllFunction() {}
 
 NotificationsGetAllFunction::~NotificationsGetAllFunction() {}
 
 bool NotificationsGetAllFunction::RunNotificationsApi() {
@@ skipping 11 matching lines @@
         StripScopeFromIdentifier(extension_->id(), *iter), true);
   }
 
   SetResult(result.release());
   SendResponse(true);
 
   return true;
 }
 
 }  // namespace extensions