Rename (Chrome)SyncExtensionFunction::RunImpl to RunSync so that the RunImpl

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/profiles/profile_helper.h"
@@ skipping 417 matching lines @@
 
   return request_id;
 }
 
 InputImeEventRouter::InputImeEventRouter()
   : next_request_id_(1) {
 }
 
 InputImeEventRouter::~InputImeEventRouter() {}
 
-bool InputImeSetCompositionFunction::RunImpl() {
+bool InputImeSetCompositionFunction::RunSync() {
   InputMethodEngineInterface* engine =
       InputImeEventRouter::GetInstance()->GetActiveEngine(extension_id());
   if (!engine) {
     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;
@@ skipping 25 matching lines @@
   int selection_end =
       params.selection_end ? *params.selection_end : params.cursor;
 
   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() {
+bool InputImeClearCompositionFunction::RunSync() {
   InputMethodEngineInterface* engine =
       InputImeEventRouter::GetInstance()->GetActiveEngine(extension_id());
   if (!engine) {
     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(new base::FundamentalValue(
       engine->ClearComposition(params.context_id, &error_)));
   return true;
 }
 
-bool InputImeCommitTextFunction::RunImpl() {
+bool InputImeCommitTextFunction::RunSync() {
   // TODO(zork): Support committing when not active.
   InputMethodEngineInterface* engine =
       InputImeEventRouter::GetInstance()->GetActiveEngine(extension_id());
   if (!engine) {
     SetResult(new base::FundamentalValue(false));
     return true;
   }
 
   scoped_ptr<CommitText::Params> parent_params(
       CommitText::Params::Create(*args_));
@@ skipping 44 matching lines @@
       event.shift_key = *(key_data[i]->shift_key);
     if (key_data[i]->caps_lock)
       event.caps_lock = *(key_data[i]->caps_lock);
     key_data_out.push_back(event);
   }
 
   engine->SendKeyEvents(params.context_id, key_data_out);
   return true;
 }
 
-bool InputImeSetCandidateWindowPropertiesFunction::RunImpl() {
+bool InputImeSetCandidateWindowPropertiesFunction::RunSync() {
   scoped_ptr<SetCandidateWindowProperties::Params> parent_params(
       SetCandidateWindowProperties::Params::Create(*args_));
   const SetCandidateWindowProperties::Params::Parameters&
       params = parent_params->parameters;
 
   InputMethodEngineInterface* engine =
       InputImeEventRouter::GetInstance()->GetEngine(extension_id(),
                                                     params.engine_id);
 
   if (!engine) {
@@ skipping 54 matching lines @@
 
   if (modified) {
     engine->SetCandidateWindowProperty(properties_out);
   }
 
   SetResult(new base::FundamentalValue(true));
 
   return true;
 }
 
-bool InputImeSetCandidatesFunction::RunImpl() {
+bool InputImeSetCandidatesFunction::RunSync() {
   InputMethodEngineInterface* engine =
       InputImeEventRouter::GetInstance()->GetActiveEngine(extension_id());
   if (!engine) {
     SetResult(new base::FundamentalValue(false));
     return true;
   }
 
   scoped_ptr<SetCandidates::Params> parent_params(
       SetCandidates::Params::Create(*args_));
   const SetCandidates::Params::Parameters& params =
@@ skipping 15 matching lines @@
       candidates_out.back().usage.title = candidates_in[i]->usage->title;
       candidates_out.back().usage.body = candidates_in[i]->usage->body;
     }
   }
 
   SetResult(new base::FundamentalValue(
       engine->SetCandidates(params.context_id, candidates_out, &error_)));
   return true;
 }
 
-bool InputImeSetCursorPositionFunction::RunImpl() {
+bool InputImeSetCursorPositionFunction::RunSync() {
   InputMethodEngineInterface* engine =
       InputImeEventRouter::GetInstance()->GetActiveEngine(extension_id());
   if (!engine) {
     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(new base::FundamentalValue(
       engine->SetCursorPosition(params.context_id, params.candidate_id,
                                 &error_)));
   return true;
 }
 
-bool InputImeSetMenuItemsFunction::RunImpl() {
+bool InputImeSetMenuItemsFunction::RunSync() {
   scoped_ptr<SetMenuItems::Params> parent_params(
       SetMenuItems::Params::Create(*args_));
   const SetMenuItems::Params::Parameters& params =
       parent_params->parameters;
 
   InputMethodEngineInterface* engine =
       InputImeEventRouter::GetInstance()->GetEngine(extension_id(),
                                                     params.engine_id);
   if (!engine) {
     error_ = kErrorEngineNotAvailable;
     return false;
   }
 
   const std::vector<linked_ptr<input_ime::MenuItem> >& items = params.items;
   std::vector<InputMethodEngineInterface::MenuItem> items_out;
 
   for (size_t i = 0; i < items.size(); ++i) {
     items_out.push_back(InputMethodEngineInterface::MenuItem());
     SetMenuItemToMenu(*items[i], &items_out.back());
   }
 
   if (!engine->SetMenuItems(items_out))
     error_ = kErrorSetMenuItemsFail;
   return true;
 }
 
-bool InputImeUpdateMenuItemsFunction::RunImpl() {
+bool InputImeUpdateMenuItemsFunction::RunSync() {
   scoped_ptr<UpdateMenuItems::Params> parent_params(
       UpdateMenuItems::Params::Create(*args_));
   const UpdateMenuItems::Params::Parameters& params =
       parent_params->parameters;
 
   InputMethodEngineInterface* engine =
       InputImeEventRouter::GetInstance()->GetEngine(extension_id(),
                                                     params.engine_id);
   if (!engine) {
     error_ = kErrorEngineNotAvailable;
     return false;
   }
 
   const std::vector<linked_ptr<input_ime::MenuItem> >& items = params.items;
   std::vector<InputMethodEngineInterface::MenuItem> items_out;
 
   for (size_t i = 0; i < items.size(); ++i) {
     items_out.push_back(InputMethodEngineInterface::MenuItem());
     SetMenuItemToMenu(*items[i], &items_out.back());
   }
 
   if (!engine->UpdateMenuItems(items_out))
     error_ = kErrorUpdateMenuItemsFail;
   return true;
 }
 
-bool InputImeDeleteSurroundingTextFunction::RunImpl() {
+bool InputImeDeleteSurroundingTextFunction::RunSync() {
   scoped_ptr<DeleteSurroundingText::Params> parent_params(
       DeleteSurroundingText::Params::Create(*args_));
   const DeleteSurroundingText::Params::Parameters& params =
       parent_params->parameters;
 
   InputMethodEngineInterface* engine =
       InputImeEventRouter::GetInstance()->GetEngine(extension_id(),
                                                     params.engine_id);
   if (!engine) {
     error_ = kErrorEngineNotAvailable;
@@ skipping 80 matching lines @@
       input_ime_event_router()->GetActiveEngine(details.extension_id);
   if (engine)
     engine->NotifyImeReady();
 }
 
 InputImeEventRouter* InputImeAPI::input_ime_event_router() {
   return InputImeEventRouter::GetInstance();
 }
 
 }  // namespace extensions