Convert most of extensions and some other random stuff to using the base namespace for Values.

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/json/json_writer.h"
 #include "base/lazy_instance.h"
 #include "base/stl_util.h"
 #include "base/strings/string_number_conversions.h"
@@ skipping 18 matching lines @@
 const char kStyleRadio[] = "radio";
 const char kStyleSeparator[] = "separator";
 const char kWindowPositionComposition[] = "composition";
 
 const char kErrorEngineNotAvailable[] = "Engine is not available";
 const char kErrorBadCandidateList[] = "Invalid candidate list provided";
 const char kErrorSetMenuItemsFail[] = "Could not create menu Items";
 const char kErrorUpdateMenuItemsFail[] = "Could not update menu Items";
 
 bool ReadMenuItems(
-    ListValue* menu_items,
+    base::ListValue* menu_items,
     std::vector<chromeos::InputMethodEngine::MenuItem>* output) {
   for (size_t i = 0; i < menu_items->GetSize(); ++i) {
-    DictionaryValue* item_dict;
+    base::DictionaryValue* item_dict;
     if (!menu_items->GetDictionary(i, &item_dict)) {
       return false;
     }
 
     std::string id;
     std::string label;
     chromeos::InputMethodEngine::MenuItemStyle style =
         chromeos::InputMethodEngine::MENU_ITEM_STYLE_NONE;
     bool visible = true;
     bool enabled = true;
@@ skipping 58 matching lines @@
     output->back().id = id;
     output->back().label = label;
     output->back().style = style;
     output->back().visible = visible;
     output->back().enabled = enabled;
     output->back().checked = checked;
 
     output->back().modified = modified;
 
     if (item_dict->HasKey(keys::kItemsKey)) {
-      ListValue* sub_list;
+      base::ListValue* sub_list;
       if (!item_dict->GetList(keys::kItemsKey, &sub_list)) {
         return false;
       }
 
       if (!ReadMenuItems(sub_list, &(output->back().children))) {
         return false;
       }
     }
   }
 
   return true;
 }
 
 static void DispatchEventToExtension(Profile* profile,
                                      const std::string& extension_id,
                                      const std::string& event_name,
-                                     scoped_ptr<ListValue> args) {
+                                     scoped_ptr<base::ListValue> args) {
   scoped_ptr<extensions::Event> event(new extensions::Event(
       event_name, args.Pass()));
   event->restrict_to_profile = profile;
   extensions::ExtensionSystem::Get(profile)->event_router()->
       DispatchEventToExtension(extension_id, event.Pass());
 }
 
 }  // namespace
 
 namespace events {
@@ skipping 20 matching lines @@
     extension_id_(extension_id),
     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 ListValue());
+    scoped_ptr<base::ListValue> args(new base::ListValue());
     args->Append(Value::CreateStringValue(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 ListValue());
+    scoped_ptr<base::ListValue> args(new base::ListValue());
     args->Append(Value::CreateStringValue(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;
 
-    DictionaryValue* dict = new DictionaryValue();
+    base::DictionaryValue* dict = new base::DictionaryValue();
     dict->SetInteger("contextID", context.id);
     dict->SetString("type", context.type);
 
-    scoped_ptr<base::ListValue> args(new ListValue());
+    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 ListValue());
+    scoped_ptr<base::ListValue> args(new base::ListValue());
     args->Append(Value::CreateIntegerValue(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;
 
-    DictionaryValue* dict = new DictionaryValue();
+    base::DictionaryValue* dict = new base::DictionaryValue();
     dict->SetInteger("contextID", context.id);
     dict->SetString("type", context.type);
 
-    scoped_ptr<base::ListValue> args(new ListValue());
+    scoped_ptr<base::ListValue> args(new base::ListValue());
     args->Append(dict);
 
     DispatchEventToExtension(profile_, extension_id_,
                              events::kOnInputContextUpdate, args.Pass());
   }
 
   virtual void OnKeyEvent(
       const std::string& engine_id,
       const InputMethodEngine::KeyboardEvent& event,
       chromeos::input_method::KeyEventHandle* key_data) OVERRIDE {
     if (profile_ == NULL || extension_id_.empty())
       return;
 
     std::string request_id =
         extensions::InputImeEventRouter::GetInstance()->AddRequest(engine_id,
                                                                    key_data);
 
-    DictionaryValue* dict = new DictionaryValue();
+    base::DictionaryValue* dict = new base::DictionaryValue();
     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 ListValue());
+    scoped_ptr<base::ListValue> args(new base::ListValue());
     args->Append(Value::CreateStringValue(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 ListValue());
+    scoped_ptr<base::ListValue> args(new base::ListValue());
     args->Append(Value::CreateStringValue(engine_id));
     args->Append(Value::CreateIntegerValue(candidate_id));
     switch (button) {
       case chromeos::InputMethodEngine::MOUSE_BUTTON_MIDDLE:
         args->Append(Value::CreateStringValue("middle"));
         break;
 
       case chromeos::InputMethodEngine::MOUSE_BUTTON_RIGHT:
         args->Append(Value::CreateStringValue("right"));
         break;
 
       case chromeos::InputMethodEngine::MOUSE_BUTTON_LEFT:
       // Default to left.
       default:
         args->Append(Value::CreateStringValue("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 ListValue());
+    scoped_ptr<base::ListValue> args(new base::ListValue());
     args->Append(Value::CreateStringValue(engine_id));
     args->Append(Value::CreateStringValue(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;
-    DictionaryValue* dict = new DictionaryValue();
+    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 ListValue);
+    scoped_ptr<ListValue> args(new base::ListValue);
     args->Append(Value::CreateStringValue(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 ListValue());
+    scoped_ptr<base::ListValue> args(new base::ListValue());
     args->Append(Value::CreateStringValue(engine_id));
 
     DispatchEventToExtension(profile_, extension_id_,
                              events::kOnReset, args.Pass());
   }
 
  private:
   Profile* profile_;
   std::string extension_id_;
   std::string engine_id_;
@@ skipping 154 matching lines @@
 InputImeEventRouter::~InputImeEventRouter() {}
 
 bool SetCompositionFunction::RunImpl() {
   chromeos::InputMethodEngine* engine =
       InputImeEventRouter::GetInstance()->GetActiveEngine(extension_id());
   if (!engine) {
     SetResult(Value::CreateBooleanValue(false));
     return true;
   }
 
-  DictionaryValue* args;
+  base::DictionaryValue* args;
   EXTENSION_FUNCTION_VALIDATE(args_->GetDictionary(0, &args));
   int context_id;
   std::string text;
   int selection_start;
   int selection_end;
   int cursor;
   std::vector<chromeos::InputMethodEngine::SegmentInfo> segments;
 
   EXTENSION_FUNCTION_VALIDATE(args->GetInteger(keys::kContextIdKey,
                                                &context_id));
   EXTENSION_FUNCTION_VALIDATE(args->GetString(keys::kTextKey, &text));
   EXTENSION_FUNCTION_VALIDATE(args->GetInteger(keys::kCursorKey, &cursor));
   if (args->HasKey(keys::kSelectionStartKey)) {
     EXTENSION_FUNCTION_VALIDATE(args->GetInteger(keys::kSelectionStartKey,
                                                  &selection_start));
   } else {
     selection_start = cursor;
   }
   if (args->HasKey(keys::kSelectionEndKey)) {
     EXTENSION_FUNCTION_VALIDATE(args->GetInteger(keys::kSelectionEndKey,
                                                  &selection_end));
   } else {
     selection_end = cursor;
   }
 
   if (args->HasKey(keys::kSegmentsKey)) {
-    ListValue* segment_list = NULL;
+    base::ListValue* segment_list = NULL;
     EXTENSION_FUNCTION_VALIDATE(args->GetList(keys::kSegmentsKey,
                                               &segment_list));
 
     for (size_t i = 0; i < segment_list->GetSize(); ++i) {
-      DictionaryValue* segment = NULL;
+      base::DictionaryValue* segment = NULL;
       if (!segment_list->GetDictionary(i, &segment))
         continue;
 
       int start;
       int end;
       std::string style;
 
       EXTENSION_FUNCTION_VALIDATE(segment->GetInteger(keys::kStartKey,
                                                       &start));
       EXTENSION_FUNCTION_VALIDATE(segment->GetInteger(keys::kEndKey, &end));
@@ skipping 22 matching lines @@
 }
 
 bool ClearCompositionFunction::RunImpl() {
   chromeos::InputMethodEngine* engine =
       InputImeEventRouter::GetInstance()->GetActiveEngine(extension_id());
   if (!engine) {
     SetResult(Value::CreateBooleanValue(false));
     return true;
   }
 
-  DictionaryValue* args;
+  base::DictionaryValue* args;
   EXTENSION_FUNCTION_VALIDATE(args_->GetDictionary(0, &args));
   int context_id;
 
   EXTENSION_FUNCTION_VALIDATE(args->GetInteger(keys::kContextIdKey,
                                                &context_id));
 
   if (engine->ClearComposition(context_id, &error_)) {
     SetResult(Value::CreateBooleanValue(true));
   } else {
     SetResult(Value::CreateBooleanValue(false));
   }
   return true;
 }
 
 bool CommitTextFunction::RunImpl() {
   // TODO(zork): Support committing when not active.
   chromeos::InputMethodEngine* engine =
       InputImeEventRouter::GetInstance()->GetActiveEngine(extension_id());
   if (!engine) {
     SetResult(Value::CreateBooleanValue(false));
     return true;
   }
 
-  DictionaryValue* args;
+  base::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));
 
   if (engine->CommitText(context_id, text.c_str(), &error_)) {
     SetResult(Value::CreateBooleanValue(true));
   } else {
     SetResult(Value::CreateBooleanValue(false));
   }
   return true;
 }
 
 bool SetCandidateWindowPropertiesFunction::RunImpl() {
-  DictionaryValue* args;
+  base::DictionaryValue* args;
   EXTENSION_FUNCTION_VALIDATE(args_->GetDictionary(0, &args));
 
   std::string engine_id;
   EXTENSION_FUNCTION_VALIDATE(args->GetString(keys::kEngineIdKey, &engine_id));
 
   chromeos::InputMethodEngine* engine =
       InputImeEventRouter::GetInstance()->GetEngine(extension_id(), engine_id);
   if (!engine) {
     SetResult(Value::CreateBooleanValue(false));
     return true;
   }
 
-  DictionaryValue* properties;
+  base::DictionaryValue* properties;
   EXTENSION_FUNCTION_VALIDATE(args->GetDictionary(keys::kPropertiesKey,
                                                   &properties));
 
   if (properties->HasKey(keys::kVisibleKey)) {
     bool visible;
     EXTENSION_FUNCTION_VALIDATE(properties->GetBoolean(keys::kVisibleKey,
                                                        &visible));
     if (!engine->SetCandidateWindowVisible(visible, &error_)) {
       SetResult(Value::CreateBooleanValue(false));
       return true;
@@ skipping 50 matching lines @@
     engine->SetCandidateWindowPosition(window_position);
   }
 
   SetResult(Value::CreateBooleanValue(true));
 
   return true;
 }
 
 #if defined(OS_CHROMEOS)
 bool SetCandidatesFunction::ReadCandidates(
-    ListValue* candidates,
+    base::ListValue* candidates,
     std::vector<chromeos::InputMethodEngine::Candidate>* output) {
   for (size_t i = 0; i < candidates->GetSize(); ++i) {
-    DictionaryValue* candidate_dict;
+    base::DictionaryValue* candidate_dict;
     EXTENSION_FUNCTION_VALIDATE(candidates->GetDictionary(i, &candidate_dict));
 
     std::string candidate;
     int id;
     std::string label;
     std::string annotation;
     chromeos::InputMethodEngine::UsageEntry usage_entry;
 
     EXTENSION_FUNCTION_VALIDATE(candidate_dict->GetString(keys::kCandidateKey,
                                                           &candidate));
     EXTENSION_FUNCTION_VALIDATE(candidate_dict->GetInteger(keys::kIdKey, &id));
 
     if (candidate_dict->HasKey(keys::kLabelKey)) {
       EXTENSION_FUNCTION_VALIDATE(candidate_dict->GetString(keys::kLabelKey,
                                                             &label));
     }
     if (candidate_dict->HasKey(keys::kAnnotationKey)) {
       EXTENSION_FUNCTION_VALIDATE(candidate_dict->GetString(
           keys::kAnnotationKey,
           &annotation));
     }
 
     if (candidate_dict->HasKey(keys::kUsageKey)) {
-      DictionaryValue* usage_dict;
+      base::DictionaryValue* usage_dict;
       EXTENSION_FUNCTION_VALIDATE(candidate_dict->GetDictionary(keys::kUsageKey,
                                                                 &usage_dict));
       EXTENSION_FUNCTION_VALIDATE(usage_dict->GetString(keys::kUsageTitleKey,
                                                         &usage_entry.title));
       EXTENSION_FUNCTION_VALIDATE(usage_dict->GetString(keys::kUsageBodyKey,
                                                         &usage_entry.body));
     }
 
     output->push_back(chromeos::InputMethodEngine::Candidate());
     output->back().value = candidate;
     output->back().id = id;
     output->back().label = label;
     output->back().annotation = annotation;
     output->back().usage = usage_entry;
 
     if (candidate_dict->HasKey(keys::kCandidatesKey)) {
-      ListValue* sub_list;
+      base::ListValue* sub_list;
       EXTENSION_FUNCTION_VALIDATE(candidate_dict->GetList(keys::kCandidatesKey,
                                                           &sub_list));
       if (!ReadCandidates(sub_list, &(output->back().candidates))) {
         error_ = kErrorBadCandidateList;
         return false;
       }
     }
   }
 
   return true;
 }
 
 bool SetCandidatesFunction::RunImpl() {
   chromeos::InputMethodEngine* engine =
       InputImeEventRouter::GetInstance()->GetActiveEngine(extension_id());
   if (!engine) {
     SetResult(Value::CreateBooleanValue(false));
     return true;
   }
 
-  DictionaryValue* args;
+  base::DictionaryValue* args;
   EXTENSION_FUNCTION_VALIDATE(args_->GetDictionary(0, &args));
 
   int context_id;
   std::vector<chromeos::InputMethodEngine::Candidate> candidates;
 
   EXTENSION_FUNCTION_VALIDATE(args->GetInteger(keys::kContextIdKey,
                                                      &context_id));
 
-  ListValue* candidate_list;
+  base::ListValue* candidate_list;
   EXTENSION_FUNCTION_VALIDATE(args->GetList(keys::kCandidatesKey,
                                             &candidate_list));
   if (!ReadCandidates(candidate_list, &candidates)) {
     error_ = kErrorBadCandidateList;
     return false;
   }
 
   std::string error;
   if (engine->SetCandidates(context_id, candidates, &error_)) {
     SetResult(Value::CreateBooleanValue(true));
   } else {
     SetResult(Value::CreateBooleanValue(false));
   }
   return true;
 }
 
 bool SetCursorPositionFunction::RunImpl() {
   chromeos::InputMethodEngine* engine =
       InputImeEventRouter::GetInstance()->GetActiveEngine(extension_id());
   if (!engine) {
     SetResult(Value::CreateBooleanValue(false));
     return true;
   }
 
-  DictionaryValue* args;
+  base::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));
 
   if (engine->SetCursorPosition(context_id, candidate_id, &error_)) {
     SetResult(Value::CreateBooleanValue(true));
   } else {
     SetResult(Value::CreateBooleanValue(false));
   }
   return true;
 }
 
 bool SetMenuItemsFunction::RunImpl() {
-  DictionaryValue* args;
+  base::DictionaryValue* args;
   EXTENSION_FUNCTION_VALIDATE(args_->GetDictionary(0, &args));
 
   std::string engine_id;
   EXTENSION_FUNCTION_VALIDATE(args->GetString(keys::kEngineIdKey, &engine_id));
 
   chromeos::InputMethodEngine* engine =
       InputImeEventRouter::GetInstance()->GetEngine(extension_id(), engine_id);
   if (!engine) {
     error_ = kErrorEngineNotAvailable;
     return false;
   }
 
-  ListValue* items;
+  base::ListValue* items;
   EXTENSION_FUNCTION_VALIDATE(args->GetList(keys::kItemsKey, &items));
 
   std::vector<chromeos::InputMethodEngine::MenuItem> menu_items;
   EXTENSION_FUNCTION_VALIDATE(ReadMenuItems(items, &menu_items));
 
   if (!engine->SetMenuItems(menu_items)) {
     error_ = kErrorSetMenuItemsFail;
   }
   return true;
 }
 
 bool UpdateMenuItemsFunction::RunImpl() {
-  DictionaryValue* args;
+  base::DictionaryValue* args;
   EXTENSION_FUNCTION_VALIDATE(args_->GetDictionary(0, &args));
 
   std::string engine_id;
   EXTENSION_FUNCTION_VALIDATE(args->GetString(keys::kEngineIdKey, &engine_id));
 
   chromeos::InputMethodEngine* engine =
       InputImeEventRouter::GetInstance()->GetEngine(extension_id(), engine_id);
   if (!engine) {
     error_ = kErrorEngineNotAvailable;
     return false;
   }
 
-  ListValue* items;
+  base::ListValue* items;
   EXTENSION_FUNCTION_VALIDATE(args->GetList(keys::kItemsKey, &items));
 
   std::vector<chromeos::InputMethodEngine::MenuItem> menu_items;
   EXTENSION_FUNCTION_VALIDATE(ReadMenuItems(items, &menu_items));
 
   if (!engine->UpdateMenuItems(menu_items)) {
     error_ = kErrorUpdateMenuItemsFail;
   }
   return true;
 }
 
 bool DeleteSurroundingTextFunction::RunImpl() {
-  DictionaryValue* args;
+  base::DictionaryValue* args;
   EXTENSION_FUNCTION_VALIDATE(args_->GetDictionary(0, &args));
 
   std::string engine_id;
   EXTENSION_FUNCTION_VALIDATE(args->GetString(keys::kEngineIdKey, &engine_id));
 
   chromeos::InputMethodEngine* engine =
       InputImeEventRouter::GetInstance()->GetEngine(extension_id(), engine_id);
   if (!engine) {
     error_ = kErrorEngineNotAvailable;
     return false;
@@ skipping 86 matching lines @@
       input_ime_event_router()->UnregisterAllImes(profile_, extension->id());
     }
   }
 }
 
 InputImeEventRouter* InputImeAPI::input_ime_event_router() {
   return InputImeEventRouter::GetInstance();
 }
 
 }  // namespace extensions