Added support for multiple parameters to Extension API callbacks.

chrome/browser/extensions/extension_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/extension_input_ime_api.h"
 
 #include "base/json/json_writer.h"
 #include "base/stl_util.h"
 #include "base/string_number_conversions.h"
 #include "base/values.h"
@@ skipping 449 matching lines @@
   : next_request_id_(1) {
 }
 
 ExtensionInputImeEventRouter::~ExtensionInputImeEventRouter() {}
 
 bool SetCompositionFunction::RunImpl() {
   chromeos::InputMethodEngine* engine =
       ExtensionInputImeEventRouter::GetInstance()->
           GetActiveEngine(extension_id());
   if (!engine) {
-    result_.reset(Value::CreateBooleanValue(false));
+    SetResult(Value::CreateBooleanValue(false));
     return true;
   }
 
   DictionaryValue* args;
   EXTENSION_FUNCTION_VALIDATE(args_->GetDictionary(0, &args));
   int context_id;
   std::string text;
   int selection_start;
   int selection_end;
   int cursor;
@@ skipping 43 matching lines @@
             chromeos::InputMethodEngine::SEGMENT_STYLE_UNDERLINE;
       } else if (style == keys::kStyleDoubleUnderline) {
         segments.back().style =
             chromeos::InputMethodEngine::SEGMENT_STYLE_DOUBLE_UNDERLINE;
       }
     }
   }
 
   if (engine->SetComposition(context_id, text.c_str(), selection_start,
                              selection_end, cursor, segments, &error_)) {
-    result_.reset(Value::CreateBooleanValue(true));
+    SetResult(Value::CreateBooleanValue(true));
   } else {
-    result_.reset(Value::CreateBooleanValue(false));
+    SetResult(Value::CreateBooleanValue(false));
   }
   return true;
 }
 
 bool ClearCompositionFunction::RunImpl() {
   chromeos::InputMethodEngine* engine =
       ExtensionInputImeEventRouter::GetInstance()->
           GetActiveEngine(extension_id());
   if (!engine) {
-    result_.reset(Value::CreateBooleanValue(false));
+    SetResult(Value::CreateBooleanValue(false));
     return true;
   }
 
   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_)) {
-    result_.reset(Value::CreateBooleanValue(true));
+    SetResult(Value::CreateBooleanValue(true));
   } else {
-    result_.reset(Value::CreateBooleanValue(false));
+    SetResult(Value::CreateBooleanValue(false));
   }
   return true;
 }
 
 bool CommitTextFunction::RunImpl() {
   // TODO(zork): Support committing when not active.
   chromeos::InputMethodEngine* engine =
       ExtensionInputImeEventRouter::GetInstance()->
           GetActiveEngine(extension_id());
   if (!engine) {
-    result_.reset(Value::CreateBooleanValue(false));
+    SetResult(Value::CreateBooleanValue(false));
     return true;
   }
 
   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_)) {
-    result_.reset(Value::CreateBooleanValue(true));
+    SetResult(Value::CreateBooleanValue(true));
   } else {
-    result_.reset(Value::CreateBooleanValue(false));
+    SetResult(Value::CreateBooleanValue(false));
   }
   return true;
 }
 
 bool SetCandidateWindowPropertiesFunction::RunImpl() {
   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 =
       ExtensionInputImeEventRouter::GetInstance()->GetEngine(extension_id(),
                                                              engine_id);
   if (!engine) {
-    result_.reset(Value::CreateBooleanValue(false));
+    SetResult(Value::CreateBooleanValue(false));
     return true;
   }
 
   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_)) {
-      result_.reset(Value::CreateBooleanValue(false));
+      SetResult(Value::CreateBooleanValue(false));
       return true;
     }
   }
 
   if (properties->HasKey(keys::kCursorVisibleKey)) {
     bool visible;
     EXTENSION_FUNCTION_VALIDATE(properties->GetBoolean(keys::kCursorVisibleKey,
                                                        &visible));
     engine->SetCandidateWindowCursorVisible(visible);
   }
@@ skipping 20 matching lines @@
   }
 
   if (properties->HasKey(keys::kAuxiliaryTextVisibleKey)) {
     bool visible;
     EXTENSION_FUNCTION_VALIDATE(properties->GetBoolean(
         keys::kAuxiliaryTextVisibleKey,
         &visible));
     engine->SetCandidateWindowAuxTextVisible(visible);
   }
 
-  result_.reset(Value::CreateBooleanValue(true));
+  SetResult(Value::CreateBooleanValue(true));
 
   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) {
     DictionaryValue* candidate_dict;
@@ skipping 36 matching lines @@
   }
 
   return true;
 }
 
 bool SetCandidatesFunction::RunImpl() {
   chromeos::InputMethodEngine* engine =
       ExtensionInputImeEventRouter::GetInstance()->
           GetActiveEngine(extension_id());
   if (!engine) {
-    result_.reset(Value::CreateBooleanValue(false));
+    SetResult(Value::CreateBooleanValue(false));
     return true;
   }
 
   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;
   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_)) {
-    result_.reset(Value::CreateBooleanValue(true));
+    SetResult(Value::CreateBooleanValue(true));
   } else {
-    result_.reset(Value::CreateBooleanValue(false));
+    SetResult(Value::CreateBooleanValue(false));
   }
   return true;
 }
 
 bool SetCursorPositionFunction::RunImpl() {
   chromeos::InputMethodEngine* engine =
       ExtensionInputImeEventRouter::GetInstance()->
           GetActiveEngine(extension_id());
   if (!engine) {
-    result_.reset(Value::CreateBooleanValue(false));
+    SetResult(Value::CreateBooleanValue(false));
     return true;
   }
 
   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_)) {
-    result_.reset(Value::CreateBooleanValue(true));
+    SetResult(Value::CreateBooleanValue(true));
   } else {
-    result_.reset(Value::CreateBooleanValue(false));
+    SetResult(Value::CreateBooleanValue(false));
   }
   return true;
 }
 
 bool SetMenuItemsFunction::RunImpl() {
   DictionaryValue* args;
   EXTENSION_FUNCTION_VALIDATE(args_->GetDictionary(0, &args));
 
   std::string engine_id;
   EXTENSION_FUNCTION_VALIDATE(args->GetString(keys::kEngineIdKey, &engine_id));
@@ skipping 51 matching lines @@
 
   bool handled = false;
   EXTENSION_FUNCTION_VALIDATE(args_->GetBoolean(1, &handled));
 
   ExtensionInputImeEventRouter::GetInstance()->OnEventHandled(
       extension_id(), request_id_str, handled);
 
   return true;
 }
 #endif