[Extensions API] Remove inline enums

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/chromeos/input_method/input_method_engine.h"
 #include "chrome/browser/chromeos/login/lock/screen_locker.h"
@@ skipping 41 matching lines @@
 
 void SetMenuItemToMenu(const input_ime::MenuItem& input,
                        InputMethodEngineInterface::MenuItem* out) {
   out->modified = 0;
   out->id = input.id;
   if (input.label) {
     out->modified |= InputMethodEngineInterface::MENU_ITEM_MODIFIED_LABEL;
     out->label = *input.label;
   }
 
-  if (input.style != input_ime::MenuItem::STYLE_NONE) {
+  if (input.style != input_ime::MENU_ITEM_STYLE_NONE) {
     out->modified |= InputMethodEngineInterface::MENU_ITEM_MODIFIED_STYLE;
     out->style = static_cast<InputMethodEngineInterface::MenuItemStyle>(
         input.style);
   }
 
   if (input.visible)
     out->modified |= InputMethodEngineInterface::MENU_ITEM_MODIFIED_VISIBLE;
   out->visible = input.visible ? *input.visible : true;
 
   if (input.checked)
@@ skipping 55 matching lines @@
 
   ~ImeObserver() override {}
 
   void OnActivate(const std::string& component_id) override {
     if (extension_id_.empty() ||
         !HasListener(input_ime::OnActivate::kEventName))
       return;
 
     scoped_ptr<base::ListValue> args(input_ime::OnActivate::Create(
         component_id,
-        input_ime::OnActivate::ParseScreen(GetCurrentScreenType())));
+        input_ime::ParseScreenType(GetCurrentScreenType())));
 
     DispatchEventToExtension(
         extension_id_, input_ime::OnActivate::kEventName, args.Pass());
   }
 
   void OnDeactivated(const std::string& component_id) override {
     if (extension_id_.empty() ||
         !HasListener(input_ime::OnDeactivated::kEventName))
       return;
 
     scoped_ptr<base::ListValue> args(
         input_ime::OnDeactivated::Create(component_id));
 
     DispatchEventToExtension(
         extension_id_, input_ime::OnDeactivated::kEventName, args.Pass());
   }
 
   void OnFocus(
       const InputMethodEngineInterface::InputContext& context) override {
     if (extension_id_.empty() || !HasListener(input_ime::OnFocus::kEventName))
       return;
 
     input_ime::InputContext context_value;
     context_value.context_id = context.id;
-    context_value.type = input_ime::InputContext::ParseType(context.type);
+    context_value.type = input_ime::ParseInputContextType(context.type);
     context_value.auto_correct = context.auto_correct;
     context_value.auto_complete = context.auto_complete;
     context_value.spell_check = context.spell_check;
 
     scoped_ptr<base::ListValue> args(input_ime::OnFocus::Create(context_value));
 
     DispatchEventToExtension(
         extension_id_, input_ime::OnFocus::kEventName, args.Pass());
   }
 
   void OnBlur(int context_id) override {
     if (extension_id_.empty() || !HasListener(input_ime::OnBlur::kEventName))
       return;
 
     scoped_ptr<base::ListValue> args(input_ime::OnBlur::Create(context_id));
 
     DispatchEventToExtension(
         extension_id_, input_ime::OnBlur::kEventName, args.Pass());
   }
 
   void OnInputContextUpdate(
       const InputMethodEngineInterface::InputContext& context) override {
     if (extension_id_.empty() ||
         !HasListener(input_ime::OnInputContextUpdate::kEventName))
       return;
 
     input_ime::InputContext context_value;
     context_value.context_id = context.id;
-    context_value.type = input_ime::InputContext::ParseType(context.type);
+    context_value.type = input_ime::ParseInputContextType(context.type);
 
     scoped_ptr<base::ListValue> args(
         input_ime::OnInputContextUpdate::Create(context_value));
 
     DispatchEventToExtension(extension_id_,
                              input_ime::OnInputContextUpdate::kEventName,
                              args.Pass());
   }
 
   void OnKeyEvent(const std::string& component_id,
@@ skipping 11 matching lines @@
       return;
     }
 
     extensions::InputImeEventRouter* ime_event_router =
         extensions::InputImeEventRouter::GetInstance();
 
     const std::string request_id =
         ime_event_router->AddRequest(component_id, key_data);
 
     input_ime::KeyboardEvent key_data_value;
-    key_data_value.type = input_ime::KeyboardEvent::ParseType(event.type);
+    key_data_value.type = input_ime::ParseKeyboardEventType(event.type);
     key_data_value.request_id = request_id;
     if (!event.extension_id.empty())
       key_data_value.extension_id.reset(new std::string(event.extension_id));
     key_data_value.key = event.key;
     key_data_value.code = event.code;
     key_data_value.alt_key.reset(new bool(event.alt_key));
     key_data_value.ctrl_key.reset(new bool(event.ctrl_key));
     key_data_value.shift_key.reset(new bool(event.shift_key));
     key_data_value.caps_lock.reset(new bool(event.caps_lock));
 
     scoped_ptr<base::ListValue> args(
         input_ime::OnKeyEvent::Create(component_id, key_data_value));
 
     DispatchEventToExtension(
         extension_id_, input_ime::OnKeyEvent::kEventName, args.Pass());
   }
 
   void OnCandidateClicked(
       const std::string& component_id,
       int candidate_id,
       InputMethodEngineInterface::MouseButtonEvent button) override {
     if (extension_id_.empty() ||
         !HasListener(input_ime::OnCandidateClicked::kEventName))
       return;
 
-    input_ime::OnCandidateClicked::Button button_enum =
-        input_ime::OnCandidateClicked::BUTTON_NONE;
+    input_ime::MouseButton button_enum = input_ime::MOUSE_BUTTON_NONE;
     switch (button) {
       case InputMethodEngineInterface::MOUSE_BUTTON_MIDDLE:
-        button_enum = input_ime::OnCandidateClicked::BUTTON_MIDDLE;
+        button_enum = input_ime::MOUSE_BUTTON_MIDDLE;
         break;
 
       case InputMethodEngineInterface::MOUSE_BUTTON_RIGHT:
-        button_enum = input_ime::OnCandidateClicked::BUTTON_RIGHT;
+        button_enum = input_ime::MOUSE_BUTTON_RIGHT;
         break;
 
       case InputMethodEngineInterface::MOUSE_BUTTON_LEFT:
       // Default to left.
       default:
-        button_enum = input_ime::OnCandidateClicked::BUTTON_LEFT;
+        button_enum = input_ime::MOUSE_BUTTON_LEFT;
         break;
     }
 
     scoped_ptr<base::ListValue> args(input_ime::OnCandidateClicked::Create(
         component_id, candidate_id, button_enum));
 
     DispatchEventToExtension(
         extension_id_, input_ime::OnCandidateClicked::kEventName, args.Pass());
   }
 
@@ skipping 269 matching lines @@
       SetComposition::Params::Create(*args_));
   const SetComposition::Params::Parameters& params = parent_params->parameters;
   std::vector<InputMethodEngineInterface::SegmentInfo> segments;
   if (params.segments) {
     const std::vector<linked_ptr<
         SetComposition::Params::Parameters::SegmentsType> >&
             segments_args = *params.segments;
     for (size_t i = 0; i < segments_args.size(); ++i) {
       EXTENSION_FUNCTION_VALIDATE(
           segments_args[i]->style !=
-          SetComposition::Params::Parameters::SegmentsType::STYLE_NONE);
+          input_ime::UNDERLINE_STYLE_NONE);
       segments.push_back(InputMethodEngineInterface::SegmentInfo());
       segments.back().start = segments_args[i]->start;
       segments.back().end = segments_args[i]->end;
       if (segments_args[i]->style ==
-          SetComposition::Params::Parameters::SegmentsType::STYLE_UNDERLINE) {
+          input_ime::UNDERLINE_STYLE_UNDERLINE) {
         segments.back().style =
             InputMethodEngineInterface::SEGMENT_STYLE_UNDERLINE;
       } else if (segments_args[i]->style ==
-                 SetComposition::Params::Parameters::SegmentsType::
-                     STYLE_DOUBLEUNDERLINE) {
+                 input_ime::UNDERLINE_STYLE_DOUBLEUNDERLINE) {
         segments.back().style =
             InputMethodEngineInterface::SEGMENT_STYLE_DOUBLE_UNDERLINE;
       } else {
         segments.back().style =
             InputMethodEngineInterface::SEGMENT_STYLE_NO_UNDERLINE;
       }
     }
   }
 
   int selection_start =
@@ skipping 66 matching lines @@
     error_ = kErrorEngineNotAvailable;
     return false;
   }
 
   const std::vector<linked_ptr<input_ime::KeyboardEvent> >& key_data =
       params.key_data;
   std::vector<chromeos::InputMethodEngineInterface::KeyboardEvent> key_data_out;
 
   for (size_t i = 0; i < key_data.size(); ++i) {
     chromeos::InputMethodEngineInterface::KeyboardEvent event;
-    event.type = input_ime::KeyboardEvent::ToString(key_data[i]->type);
+    event.type = input_ime::ToString(key_data[i]->type);
     event.key = key_data[i]->key;
     event.code = key_data[i]->code;
     event.key_code = key_data[i]->key_code.get() ? *(key_data[i]->key_code) : 0;
     if (key_data[i]->alt_key)
       event.alt_key = *(key_data[i]->alt_key);
     if (key_data[i]->ctrl_key)
       event.ctrl_key = *(key_data[i]->ctrl_key);
     if (key_data[i]->shift_key)
       event.shift_key = *(key_data[i]->shift_key);
     if (key_data[i]->caps_lock)
@@ skipping 41 matching lines @@
   if (properties.vertical) {
     properties_out.is_vertical = *properties.vertical;
     modified = true;
   }
 
   if (properties.page_size) {
     properties_out.page_size = *properties.page_size;
     modified = true;
   }
 
-  if (properties.window_position ==
-      SetCandidateWindowProperties::Params::Parameters::Properties::
-          WINDOW_POSITION_COMPOSITION) {
+  if (properties.window_position == input_ime::WINDOW_POSITION_COMPOSITION) {
     properties_out.show_window_at_composition = true;
     modified = true;
-  } else if (properties.window_position ==
-             SetCandidateWindowProperties::Params::Parameters::Properties::
-                 WINDOW_POSITION_CURSOR) {
+  } else if (properties.window_position == input_ime::WINDOW_POSITION_CURSOR) {
     properties_out.show_window_at_composition = false;
     modified = true;
   }
 
   if (properties.auxiliary_text) {
     properties_out.auxiliary_text = *properties.auxiliary_text;
     modified = true;
   }
 
   if (properties.auxiliary_text_visible) {
@@ skipping 195 matching lines @@
   // Notifies the IME extension for IME ready with onActivate/onFocus events.
   if (engine)
     engine->Enable(engine->GetActiveComponentId());
 }
 
 InputImeEventRouter* InputImeAPI::input_ime_event_router() {
   return InputImeEventRouter::GetInstance();
 }
 
 }  // namespace extensions