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

chrome/browser/extensions/api/input_ime/input_ime_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/input_ime/input_ime_api.h"
 
 #include "base/strings/string_number_conversions.h"
 #include "base/values.h"
 #include "chrome/browser/chrome_notification_types.h"
 #include "chrome/browser/chromeos/input_method/input_method_engine.h"
@@ skipping 93 matching lines @@
     engine_id_(engine_id) {
   }
 
   virtual ~ImeObserver() {}
 
   virtual void OnActivate(const std::string& engine_id) OVERRIDE {
     if (profile_ == NULL || extension_id_.empty())
       return;
 
     scoped_ptr<base::ListValue> args(new base::ListValue());
-    args->Append(Value::CreateStringValue(engine_id));
+    args->Append(new base::StringValue(engine_id));
 
     DispatchEventToExtension(profile_, extension_id_,
                              events::kOnActivate, args.Pass());
   }
 
   virtual void OnDeactivated(const std::string& engine_id) OVERRIDE {
     if (profile_ == NULL || extension_id_.empty())
       return;
 
     scoped_ptr<base::ListValue> args(new base::ListValue());
-    args->Append(Value::CreateStringValue(engine_id));
+    args->Append(new base::StringValue(engine_id));
 
     DispatchEventToExtension(profile_, extension_id_,
                              events::kOnDeactivated, args.Pass());
   }
 
   virtual void OnFocus(
       const InputMethodEngine::InputContext& context) OVERRIDE {
     if (profile_ == NULL || extension_id_.empty())
       return;
 
     base::DictionaryValue* dict = new base::DictionaryValue();
     dict->SetInteger("contextID", context.id);
     dict->SetString("type", context.type);
 
     scoped_ptr<base::ListValue> args(new base::ListValue());
     args->Append(dict);
 
     DispatchEventToExtension(profile_, extension_id_,
                              events::kOnFocus, args.Pass());
   }
 
   virtual void OnBlur(int context_id) OVERRIDE {
     if (profile_ == NULL || extension_id_.empty())
       return;
 
     scoped_ptr<base::ListValue> args(new base::ListValue());
-    args->Append(Value::CreateIntegerValue(context_id));
+    args->Append(new base::FundamentalValue(context_id));
 
     DispatchEventToExtension(profile_, extension_id_,
                              events::kOnBlur, args.Pass());
   }
 
   virtual void OnInputContextUpdate(
       const InputMethodEngine::InputContext& context) OVERRIDE {
     if (profile_ == NULL || extension_id_.empty())
       return;
 
@@ skipping 23 matching lines @@
     dict->SetString("type", event.type);
     dict->SetString("requestId", request_id);
     dict->SetString("key", event.key);
     dict->SetString("code", event.code);
     dict->SetBoolean("altKey", event.alt_key);
     dict->SetBoolean("ctrlKey", event.ctrl_key);
     dict->SetBoolean("shiftKey", event.shift_key);
     dict->SetBoolean("capsLock", event.caps_lock);
 
     scoped_ptr<base::ListValue> args(new base::ListValue());
-    args->Append(Value::CreateStringValue(engine_id));
+    args->Append(new base::StringValue(engine_id));
     args->Append(dict);
 
     DispatchEventToExtension(profile_, extension_id_,
                              events::kOnKeyEvent, args.Pass());
   }
 
   virtual void OnCandidateClicked(
       const std::string& engine_id,
       int candidate_id,
       chromeos::InputMethodEngine::MouseButtonEvent button) OVERRIDE {
     if (profile_ == NULL || extension_id_.empty())
       return;
 
     scoped_ptr<base::ListValue> args(new base::ListValue());
-    args->Append(Value::CreateStringValue(engine_id));
-    args->Append(Value::CreateIntegerValue(candidate_id));
+    args->Append(new base::StringValue(engine_id));
+    args->Append(new base::FundamentalValue(candidate_id));
     switch (button) {
       case chromeos::InputMethodEngine::MOUSE_BUTTON_MIDDLE:
-        args->Append(Value::CreateStringValue("middle"));
+        args->Append(new base::StringValue("middle"));
         break;
 
       case chromeos::InputMethodEngine::MOUSE_BUTTON_RIGHT:
-        args->Append(Value::CreateStringValue("right"));
+        args->Append(new base::StringValue("right"));
         break;
 
       case chromeos::InputMethodEngine::MOUSE_BUTTON_LEFT:
       // Default to left.
       default:
-        args->Append(Value::CreateStringValue("left"));
+        args->Append(new base::StringValue("left"));
         break;
     }
 
     DispatchEventToExtension(profile_, extension_id_,
                              events::kOnCandidateClicked, args.Pass());
   }
 
   virtual void OnMenuItemActivated(const std::string& engine_id,
                                    const std::string& menu_id) OVERRIDE {
     if (profile_ == NULL || extension_id_.empty())
       return;
 
     scoped_ptr<base::ListValue> args(new base::ListValue());
-    args->Append(Value::CreateStringValue(engine_id));
-    args->Append(Value::CreateStringValue(menu_id));
+    args->Append(new base::StringValue(engine_id));
+    args->Append(new base::StringValue(menu_id));
 
     DispatchEventToExtension(profile_, extension_id_,
                              events::kOnMenuItemActivated, args.Pass());
   }
 
   virtual void OnSurroundingTextChanged(const std::string& engine_id,
                                         const std::string& text,
                                         int cursor_pos,
                                         int anchor_pos) OVERRIDE {
     if (profile_ == NULL || extension_id_.empty())
       return;
     base::DictionaryValue* dict = new base::DictionaryValue();
     dict->SetString("text", text);
     dict->SetInteger("focus", cursor_pos);
     dict->SetInteger("anchor", anchor_pos);
 
     scoped_ptr<ListValue> args(new base::ListValue);
-    args->Append(Value::CreateStringValue(engine_id));
+    args->Append(new base::StringValue(engine_id));
     args->Append(dict);
 
     DispatchEventToExtension(profile_, extension_id_,
                              events::kOnSurroundingTextChanged, args.Pass());
   }
 
   virtual void OnReset(const std::string& engine_id) OVERRIDE {
     if (profile_ == NULL || extension_id_.empty())
       return;
     scoped_ptr<base::ListValue> args(new base::ListValue());
-    args->Append(Value::CreateStringValue(engine_id));
+    args->Append(new base::StringValue(engine_id));
 
     DispatchEventToExtension(profile_, extension_id_,
                              events::kOnReset, args.Pass());
   }
 
  private:
   Profile* profile_;
   std::string extension_id_;
   std::string engine_id_;
 
@@ skipping 149 matching lines @@
 InputImeEventRouter::InputImeEventRouter()
   : next_request_id_(1) {
 }
 
 InputImeEventRouter::~InputImeEventRouter() {}
 
 bool InputImeSetCompositionFunction::RunImpl() {
   chromeos::InputMethodEngine* engine =
       InputImeEventRouter::GetInstance()->GetActiveEngine(extension_id());
   if (!engine) {
-    SetResult(Value::CreateBooleanValue(false));
+    SetResult(new base::FundamentalValue(false));
     return true;
   }
 
   scoped_ptr<SetComposition::Params> parent_params(
       SetComposition::Params::Create(*args_));
   const SetComposition::Params::Parameters& params = parent_params->parameters;
   std::vector<chromeos::InputMethodEngine::SegmentInfo> segments;
   if (params.segments) {
     const std::vector<linked_ptr<
         SetComposition::Params::Parameters::SegmentsType> >&
@@ skipping 14 matching lines @@
             chromeos::InputMethodEngine::SEGMENT_STYLE_DOUBLE_UNDERLINE;
       }
     }
   }
 
   int selection_start =
       params.selection_start ? *params.selection_start : params.cursor;
   int selection_end =
       params.selection_end ? *params.selection_end : params.cursor;
 
-  SetResult(Value::CreateBooleanValue(
+  SetResult(new base::FundamentalValue(
       engine->SetComposition(params.context_id, params.text.c_str(),
                              selection_start, selection_end, params.cursor,
                              segments, &error_)));
   return true;
 }
 
 bool InputImeClearCompositionFunction::RunImpl() {
   chromeos::InputMethodEngine* engine =
       InputImeEventRouter::GetInstance()->GetActiveEngine(extension_id());
   if (!engine) {
-    SetResult(Value::CreateBooleanValue(false));
+    SetResult(new base::FundamentalValue(false));
     return true;
   }
 
   scoped_ptr<ClearComposition::Params> parent_params(
       ClearComposition::Params::Create(*args_));
   const ClearComposition::Params::Parameters& params =
       parent_params->parameters;
 
-  SetResult(Value::CreateBooleanValue(
+  SetResult(new base::FundamentalValue(
       engine->ClearComposition(params.context_id, &error_)));
   return true;
 }
 
 bool InputImeCommitTextFunction::RunImpl() {
   // TODO(zork): Support committing when not active.
   chromeos::InputMethodEngine* engine =
       InputImeEventRouter::GetInstance()->GetActiveEngine(extension_id());
   if (!engine) {
-    SetResult(Value::CreateBooleanValue(false));
+    SetResult(new base::FundamentalValue(false));
     return true;
   }
 
   scoped_ptr<CommitText::Params> parent_params(
       CommitText::Params::Create(*args_));
   const CommitText::Params::Parameters& params =
       parent_params->parameters;
 
-  SetResult(Value::CreateBooleanValue(
+  SetResult(new base::FundamentalValue(
       engine->CommitText(params.context_id, params.text.c_str(), &error_)));
   return true;
 }
 
 bool InputImeSetCandidateWindowPropertiesFunction::RunImpl() {
   scoped_ptr<SetCandidateWindowProperties::Params> parent_params(
       SetCandidateWindowProperties::Params::Create(*args_));
   const SetCandidateWindowProperties::Params::Parameters&
       params = parent_params->parameters;
 
   chromeos::InputMethodEngine* engine =
       InputImeEventRouter::GetInstance()->GetEngine(extension_id(),
                                                     params.engine_id);
 
   if (!engine) {
-    SetResult(Value::CreateBooleanValue(false));
+    SetResult(new base::FundamentalValue(false));
     return true;
   }
 
   const SetCandidateWindowProperties::Params::Parameters::Properties&
       properties = params.properties;
 
   if (properties.visible &&
       !engine->SetCandidateWindowVisible(*properties.visible, &error_)) {
-    SetResult(Value::CreateBooleanValue(false));
+    SetResult(new base::FundamentalValue(false));
     return true;
   }
 
   if (properties.cursor_visible)
     engine->SetCandidateWindowCursorVisible(*properties.cursor_visible);
 
   if (properties.vertical)
     engine->SetCandidateWindowVertical(*properties.vertical);
 
   if (properties.page_size)
@@ skipping 12 matching lines @@
           WINDOW_POSITION_COMPOSITION) {
     engine->SetCandidateWindowPosition(
         chromeos::InputMethodEngine::WINDOW_POS_COMPOSITTION);
   } else if (properties.window_position ==
              SetCandidateWindowProperties::Params::Parameters::Properties::
                  WINDOW_POSITION_CURSOR) {
     engine->SetCandidateWindowPosition(
         chromeos::InputMethodEngine::WINDOW_POS_CURSOR);
   }
 
-  SetResult(Value::CreateBooleanValue(true));
+  SetResult(new base::FundamentalValue(true));
 
   return true;
 }
 
 #if defined(OS_CHROMEOS)
 bool InputImeSetCandidatesFunction::RunImpl() {
   chromeos::InputMethodEngine* engine =
       InputImeEventRouter::GetInstance()->GetActiveEngine(extension_id());
   if (!engine) {
-    SetResult(Value::CreateBooleanValue(false));
+    SetResult(new base::FundamentalValue(false));
     return true;
   }
 
   scoped_ptr<SetCandidates::Params> parent_params(
       SetCandidates::Params::Create(*args_));
   const SetCandidates::Params::Parameters& params =
       parent_params->parameters;
 
   std::vector<chromeos::InputMethodEngine::Candidate> candidates_out;
   const std::vector<linked_ptr<
       SetCandidates::Params::Parameters::CandidatesType> >& candidates_in =
           params.candidates;
   for (size_t i = 0; i < candidates_in.size(); ++i) {
     candidates_out.push_back(chromeos::InputMethodEngine::Candidate());
     candidates_out.back().value = candidates_in[i]->candidate;
     candidates_out.back().id = candidates_in[i]->id;
     if (candidates_in[i]->label)
       candidates_out.back().label = *candidates_in[i]->label;
     if (candidates_in[i]->annotation)
       candidates_out.back().annotation = *candidates_in[i]->annotation;
     if (candidates_in[i]->usage) {
       candidates_out.back().usage.title = candidates_in[i]->usage->title;
       candidates_out.back().usage.body = candidates_in[i]->usage->body;
     }
   }
 
-  SetResult(Value::CreateBooleanValue(
+  SetResult(new base::FundamentalValue(
       engine->SetCandidates(params.context_id, candidates_out, &error_)));
   return true;
 }
 
 bool InputImeSetCursorPositionFunction::RunImpl() {
   chromeos::InputMethodEngine* engine =
       InputImeEventRouter::GetInstance()->GetActiveEngine(extension_id());
   if (!engine) {
-    SetResult(Value::CreateBooleanValue(false));
+    SetResult(new base::FundamentalValue(false));
     return true;
   }
 
   scoped_ptr<SetCursorPosition::Params> parent_params(
       SetCursorPosition::Params::Create(*args_));
   const SetCursorPosition::Params::Parameters& params =
       parent_params->parameters;
 
-  SetResult(Value::CreateBooleanValue(
+  SetResult(new base::FundamentalValue(
       engine->SetCursorPosition(params.context_id, params.candidate_id,
                                 &error_)));
   return true;
 }
 
 bool InputImeSetMenuItemsFunction::RunImpl() {
   scoped_ptr<SetMenuItems::Params> parent_params(
       SetMenuItems::Params::Create(*args_));
   const SetMenuItems::Params::Parameters& params =
       parent_params->parameters;
@@ skipping 121 matching lines @@
     if (input_components->size() > 0)
       input_ime_event_router()->UnregisterAllImes(profile_, extension->id());
   }
 }
 
 InputImeEventRouter* InputImeAPI::input_ime_event_router() {
   return InputImeEventRouter::GetInstance();
 }
 
 }  // namespace extensions