more changes

chrome/browser/extensions/extension_input_ime_api.cc

 // Copyright (c) 2011 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/extension_input_ime_api.h"
 
 #include "base/json/json_writer.h"
 #include "base/values.h"
 #include "chrome/browser/chromeos/input_method/input_method_engine.h"
 #include "chrome/browser/extensions/extension_event_router.h"
@@ skipping 26 matching lines @@
   }
 
   virtual ~ImeObserver() {
   }
 
   virtual void OnActivate(const std::string& engine_id) {
     if (profile_ == NULL || extension_id_.empty())
       return;
 
     ListValue args;
-    args.Append(Value::CreateStringValue(engine_id));
+    args.Append(base::StringValue::New(engine_id));
 
     std::string json_args;
     base::JSONWriter::Write(&args, false, &json_args);
     profile_->GetExtensionEventRouter()->DispatchEventToExtension(
         extension_id_, events::kOnActivate, json_args, profile_, GURL());
   }
 
   virtual void OnDeactivated(const std::string& engine_id) {
     if (profile_ == NULL || extension_id_.empty())
       return;
 
     ListValue args;
-    args.Append(Value::CreateStringValue(engine_id));
+    args.Append(base::StringValue::New(engine_id));
 
     std::string json_args;
     base::JSONWriter::Write(&args, false, &json_args);
     profile_->GetExtensionEventRouter()->DispatchEventToExtension(
         extension_id_, events::kOnDeactivated, json_args, profile_, GURL());
   }
 
   virtual void OnFocus(const InputMethodEngine::InputContext& context) {
     if (profile_ == NULL || extension_id_.empty())
       return;
 
     DictionaryValue* dict = new DictionaryValue();
     dict->SetInteger("contextID", context.id);
     dict->SetString("type", context.type);
 
     ListValue args;
     args.Append(dict);
 
     std::string json_args;
     base::JSONWriter::Write(&args, false, &json_args);
     profile_->GetExtensionEventRouter()->DispatchEventToExtension(
         extension_id_, events::kOnFocus, json_args, profile_, GURL());
   }
 
   virtual void OnBlur(int context_id) {
     if (profile_ == NULL || extension_id_.empty())
       return;
 
     ListValue args;
-    args.Append(Value::CreateIntegerValue(context_id));
+    args.Append(base::NumberValue::New(context_id));
 
     std::string json_args;
     base::JSONWriter::Write(&args, false, &json_args);
     profile_->GetExtensionEventRouter()->DispatchEventToExtension(
         extension_id_, events::kOnBlur, json_args, profile_, GURL());
   }
 
   virtual void OnInputContextUpdate(
       const InputMethodEngine::InputContext& context) {
     if (profile_ == NULL || extension_id_.empty())
@@ skipping 20 matching lines @@
 
     DictionaryValue* dict = new DictionaryValue();
     dict->SetString("type", event.type);
     dict->SetString("key", event.key);
     dict->SetString("keyCode", event.key_code);
     dict->SetBoolean("altKey", event.alt_key);
     dict->SetBoolean("ctrlKey", event.ctrl_key);
     dict->SetBoolean("shiftKey", event.shift_key);
 
     ListValue args;
-    args.Append(Value::CreateStringValue(engine_id));
+    args.Append(base::StringValue::New(engine_id));
     args.Append(dict);
 
     std::string json_args;
     base::JSONWriter::Write(&args, false, &json_args);
     profile_->GetExtensionEventRouter()->DispatchEventToExtension(
         extension_id_, events::kOnKeyEvent, json_args, profile_, GURL());
   }
 
   virtual void OnCandidateClicked(const std::string& engine_id,
                                   int candidate_id,
                                   int button) {
     if (profile_ == NULL || extension_id_.empty())
       return;
 
     ListValue args;
-    args.Append(Value::CreateStringValue(engine_id));
-    args.Append(Value::CreateIntegerValue(candidate_id));
+    args.Append(base::StringValue::New(engine_id));
+    args.Append(base::NumberValue::New(candidate_id));
     switch (button) {
       case chromeos::InputMethodEngine::MOUSE_BUTTON_MIDDLE:
-        args.Append(Value::CreateStringValue("middle"));
+        args.Append(base::StringValue::New("middle"));
         break;
 
       case chromeos::InputMethodEngine::MOUSE_BUTTON_RIGHT:
-        args.Append(Value::CreateStringValue("right"));
+        args.Append(base::StringValue::New("right"));
         break;
 
       case chromeos::InputMethodEngine::MOUSE_BUTTON_LEFT:
       // Default to left.
       default:
-        args.Append(Value::CreateStringValue("left"));
+        args.Append(base::StringValue::New("left"));
         break;
     }
 
     std::string json_args;
     base::JSONWriter::Write(&args, false, &json_args);
     profile_->GetExtensionEventRouter()->DispatchEventToExtension(
         extension_id_, events::kOnCandidateClicked, json_args, profile_,
         GURL());
   }
 
   virtual void OnMenuItemActivated(const std::string& engine_id,
                                    const std::string& menu_id) {
     if (profile_ == NULL || extension_id_.empty())
       return;
 
     ListValue args;
-    args.Append(Value::CreateStringValue(engine_id));
-    args.Append(Value::CreateStringValue(menu_id));
+    args.Append(base::StringValue::New(engine_id));
+    args.Append(base::StringValue::New(menu_id));
 
     std::string json_args;
     base::JSONWriter::Write(&args, false, &json_args);
     profile_->GetExtensionEventRouter()->DispatchEventToExtension(
         extension_id_, events::kOnMenuItemActivated, json_args, profile_,
         GURL());
   }
 
  private:
   Profile* profile_;
@@ skipping 105 matching lines @@
   }
   return NULL;
 }
 
 bool SetCompositionFunction::RunImpl() {
   chromeos::InputMethodEngine* engine =
       ExtensionInputImeEventRouter::GetInstance()->
           GetActiveEngine(extension_id());
   if (!engine) {
     if (has_callback()) {
-      result_.reset(Value::CreateBooleanValue(false));
+      result_.reset(base::FalseValue());
     }
     return true;
   }
 
   DictionaryValue* args;
   EXTENSION_FUNCTION_VALIDATE(args_->GetDictionary(0, &args));
   int context_id;
   std::string text;
   int selection_start;
   int selection_end;
@@ skipping 38 matching lines @@
       segments.back().style =
           chromeos::InputMethodEngine::SEGMENT_STYLE_DOUBLE_UNDERLINE;
     }
   }
 
   std::string error;
 
   if (engine->SetComposition(context_id, text.c_str(), selection_start,
                              selection_end, segments, &error)) {
     if (has_callback()) {
-      result_.reset(Value::CreateBooleanValue(true));
+      result_.reset(base::TrueValue());
     }
     return true;
   } else {
     if (has_callback()) {
-      result_.reset(Value::CreateBooleanValue(false));
+      result_.reset(base::FalseValue());
     }
     return false;
   }
 }
 
 bool ClearCompositionFunction::RunImpl() {
   chromeos::InputMethodEngine* engine =
       ExtensionInputImeEventRouter::GetInstance()->
           GetActiveEngine(extension_id());
   if (!engine) {
     return false;
   }
 
   DictionaryValue* args;
   EXTENSION_FUNCTION_VALIDATE(args_->GetDictionary(0, &args));
   int context_id;
 
   EXTENSION_FUNCTION_VALIDATE(args->GetInteger(keys::kContextIdKey,
                                                &context_id));
 
   std::string error;
   if (engine->ClearComposition(context_id, &error)) {
     if (has_callback()) {
-      result_.reset(Value::CreateBooleanValue(true));
+      result_.reset(base::TrueValue());
     }
     return true;
   } else {
     if (has_callback()) {
-      result_.reset(Value::CreateBooleanValue(false));
+      result_.reset(base::FalseValue());
     }
     return false;
   }
 }
 
 bool CommitTextFunction::RunImpl() {
   // TODO(zork): Support committing when not active.
   chromeos::InputMethodEngine* engine =
       ExtensionInputImeEventRouter::GetInstance()->
           GetActiveEngine(extension_id());
   if (!engine) {
     return false;
   }
 
   DictionaryValue* args;
   EXTENSION_FUNCTION_VALIDATE(args_->GetDictionary(0, &args));
   int context_id;
   std::string text;
 
   EXTENSION_FUNCTION_VALIDATE(args->GetInteger(keys::kContextIdKey,
                                                      &context_id));
   EXTENSION_FUNCTION_VALIDATE(args->GetString(keys::kTextKey, &text));
 
   std::string error;
   if (engine->CommitText(context_id, text.c_str(), &error)) {
     if (has_callback()) {
-      result_.reset(Value::CreateBooleanValue(true));
+      result_.reset(base::TrueValue());
     }
     return true;
   } else {
     if (has_callback()) {
-      result_.reset(Value::CreateBooleanValue(false));
+      result_.reset(base::FalseValue());
     }
     return false;
   }
 }
 
 bool SetCandidateWindowPropertiesFunction::RunImpl() {
   DictionaryValue* args;
   EXTENSION_FUNCTION_VALIDATE(args_->GetDictionary(0, &args));
 
   std::string engine_id;
@@ skipping 51 matching lines @@
 
   if (properties->HasKey(keys::kAuxiliaryTextVisibleKey)) {
     bool visible;
     EXTENSION_FUNCTION_VALIDATE(properties->GetBoolean(
         keys::kAuxiliaryTextVisibleKey,
         &visible));
     engine->SetCandidateWindowAuxTextVisible(visible);
   }
 
   if (has_callback()) {
-    result_.reset(Value::CreateBooleanValue(true));
+    result_.reset(base::TrueValue());
   }
 
   return true;
 }
 
 #if defined(OS_CHROMEOS)
 bool SetCandidatesFunction::ReadCandidates(
     ListValue* candidates,
     std::vector<chromeos::InputMethodEngine::Candidate>* output) {
   for (size_t i = 0; i < candidates->GetSize(); ++i) {
@@ skipping 58 matching lines @@
   ListValue* candidate_list;
   EXTENSION_FUNCTION_VALIDATE(args->GetList(keys::kCandidatesKey,
                                             &candidate_list));
   if (!ReadCandidates(candidate_list, &candidates)) {
     return false;
   }
 
   std::string error;
   if (engine->SetCandidates(context_id, candidates, &error)) {
     if (has_callback()) {
-      result_.reset(Value::CreateBooleanValue(true));
+      result_.reset(base::TrueValue());
     }
     return true;
   } else {
     if (has_callback()) {
-      result_.reset(Value::CreateBooleanValue(false));
+      result_.reset(base::FalseValue());
     }
     return false;
   }
 }
 
 bool SetCursorPositionFunction::RunImpl() {
   chromeos::InputMethodEngine* engine =
       ExtensionInputImeEventRouter::GetInstance()->
           GetActiveEngine(extension_id());
   if (!engine) {
     return false;
   }
 
   DictionaryValue* args;
   EXTENSION_FUNCTION_VALIDATE(args_->GetDictionary(0, &args));
   int context_id;
   int candidate_id;
 
   EXTENSION_FUNCTION_VALIDATE(args->GetInteger(keys::kContextIdKey,
                                                      &context_id));
   EXTENSION_FUNCTION_VALIDATE(args->GetInteger(keys::kCandidateIdKey,
                                                      &candidate_id));
 
   std::string error;
   if (engine->SetCursorPosition(context_id, candidate_id, &error)) {
     if (has_callback()) {
-      result_.reset(Value::CreateBooleanValue(true));
+      result_.reset(base::TrueValue());
     }
     return true;
   } else {
     if (has_callback()) {
-      result_.reset(Value::CreateBooleanValue(false));
+      result_.reset(base::FalseValue());
     }
     return false;
   }
   return true;
 }
 
 bool SetMenuItemsFunction::RunImpl() {
   // TODO
   return true;
 }
 
 bool UpdateMenuItemsFunction::RunImpl() {
   // TODO
   return true;
 }
 #endif