[Extensions API] Remove inline enums

chrome/browser/extensions/api/tabs/tabs_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/tabs/tabs_api.h"
 
 #include <algorithm>
 #include <limits>
 #include <vector>
 
@@ skipping 170 matching lines @@
   }
 }
 
 }  // namespace
 
 void ZoomModeToZoomSettings(ZoomController::ZoomMode zoom_mode,
                             api::tabs::ZoomSettings* zoom_settings) {
   DCHECK(zoom_settings);
   switch (zoom_mode) {
     case ZoomController::ZOOM_MODE_DEFAULT:
-      zoom_settings->mode = api::tabs::ZoomSettings::MODE_AUTOMATIC;
-      zoom_settings->scope = api::tabs::ZoomSettings::SCOPE_PER_ORIGIN;
+      zoom_settings->mode = api::tabs::ZOOM_SETTINGS_MODE_AUTOMATIC;
+      zoom_settings->scope = api::tabs::ZOOM_SETTINGS_SCOPE_PER_ORIGIN;
       break;
     case ZoomController::ZOOM_MODE_ISOLATED:
-      zoom_settings->mode = api::tabs::ZoomSettings::MODE_AUTOMATIC;
-      zoom_settings->scope = api::tabs::ZoomSettings::SCOPE_PER_TAB;
+      zoom_settings->mode = api::tabs::ZOOM_SETTINGS_MODE_AUTOMATIC;
+      zoom_settings->scope = api::tabs::ZOOM_SETTINGS_SCOPE_PER_TAB;
       break;
     case ZoomController::ZOOM_MODE_MANUAL:
-      zoom_settings->mode = api::tabs::ZoomSettings::MODE_MANUAL;
-      zoom_settings->scope = api::tabs::ZoomSettings::SCOPE_PER_TAB;
+      zoom_settings->mode = api::tabs::ZOOM_SETTINGS_MODE_MANUAL;
+      zoom_settings->scope = api::tabs::ZOOM_SETTINGS_SCOPE_PER_TAB;
       break;
     case ZoomController::ZOOM_MODE_DISABLED:
-      zoom_settings->mode = api::tabs::ZoomSettings::MODE_DISABLED;
-      zoom_settings->scope = api::tabs::ZoomSettings::SCOPE_PER_TAB;
+      zoom_settings->mode = api::tabs::ZOOM_SETTINGS_MODE_DISABLED;
+      zoom_settings->scope = api::tabs::ZOOM_SETTINGS_SCOPE_PER_TAB;
       break;
   }
 }
 
 // Windows ---------------------------------------------------------------------
 
 bool WindowsGetFunction::RunSync() {
   scoped_ptr<windows::Get::Params> params(windows::Get::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params.get());
 
@@ skipping 210 matching lines @@
     return false;
   }
   if (open_incognito_window) {
     window_profile = window_profile->GetOffTheRecordProfile();
   }
 
   if (create_data) {
     // Figure out window type before figuring out bounds so that default
     // bounds can be set according to the window type.
     switch (create_data->type) {
-      case windows::Create::Params::CreateData::TYPE_POPUP:
+      case windows::CREATE_TYPE_POPUP:
         window_type = Browser::TYPE_POPUP;
         extension_id = extension()->id();
         break;
-      case windows::Create::Params::CreateData::TYPE_PANEL:
-      case windows::Create::Params::CreateData::TYPE_DETACHED_PANEL: {
+      case windows::CREATE_TYPE_PANEL:
+      case windows::CREATE_TYPE_DETACHED_PANEL: {
         extension_id = extension()->id();
         bool use_panels = PanelManager::ShouldUsePanels(extension_id);
         if (use_panels) {
           create_panel = true;
           // Non-ash supports both docked and detached panel types.
           if (chrome::GetActiveDesktop() != chrome::HOST_DESKTOP_TYPE_ASH &&
-              create_data->type ==
-              windows::Create::Params::CreateData::TYPE_DETACHED_PANEL) {
+              create_data->type == windows::CREATE_TYPE_DETACHED_PANEL) {
             panel_create_mode = PanelManager::CREATE_AS_DETACHED;
           }
         } else {
           window_type = Browser::TYPE_POPUP;
         }
         break;
       }
-      case windows::Create::Params::CreateData::TYPE_NONE:
-      case windows::Create::Params::CreateData::TYPE_NORMAL:
+      case windows::CREATE_TYPE_NONE:
+      case windows::CREATE_TYPE_NORMAL:
         break;
       default:
         error_ = keys::kInvalidWindowTypeError;
         return false;
     }
 
     // Initialize default window bounds according to window type.
     if (window_type == Browser::TYPE_TABBED ||
         window_type == Browser::TYPE_POPUP ||
         create_panel) {
@@ skipping 151 matching lines @@
       windows::Update::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params);
 
   WindowController* controller;
   if (!windows_util::GetWindowFromWindowID(this, params->window_id,
                                             &controller))
     return false;
 
   ui::WindowShowState show_state = ui::SHOW_STATE_DEFAULT;  // No change.
   switch (params->update_info.state) {
-    case windows::Update::Params::UpdateInfo::STATE_NORMAL:
+    case windows::WINDOW_STATE_NORMAL:
       show_state = ui::SHOW_STATE_NORMAL;
       break;
-    case windows::Update::Params::UpdateInfo::STATE_MINIMIZED:
+    case windows::WINDOW_STATE_MINIMIZED:
       show_state = ui::SHOW_STATE_MINIMIZED;
       break;
-    case windows::Update::Params::UpdateInfo::STATE_MAXIMIZED:
+    case windows::WINDOW_STATE_MAXIMIZED:
       show_state = ui::SHOW_STATE_MAXIMIZED;
       break;
-    case windows::Update::Params::UpdateInfo::STATE_FULLSCREEN:
+    case windows::WINDOW_STATE_FULLSCREEN:
       show_state = ui::SHOW_STATE_FULLSCREEN;
       break;
-    case windows::Update::Params::UpdateInfo::STATE_NONE:
+    case windows::WINDOW_STATE_NONE:
       break;
     default:
       error_ = keys::kInvalidWindowStateError;
       return false;
   }
 
   if (show_state != ui::SHOW_STATE_FULLSCREEN &&
       show_state != ui::SHOW_STATE_DEFAULT)
     controller->SetFullscreenMode(false, extension()->url());
 
@@ skipping 144 matching lines @@
 
   SetResult(ExtensionTabUtil::CreateTabList(browser, extension()));
 
   return true;
 }
 
 bool TabsQueryFunction::RunSync() {
   scoped_ptr<tabs::Query::Params> params(tabs::Query::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params.get());
 
-  bool loading_status_set = params->query_info.status !=
-      tabs::Query::Params::QueryInfo::STATUS_NONE;
-  bool loading = params->query_info.status ==
-      tabs::Query::Params::QueryInfo::STATUS_LOADING;
+  bool loading_status_set = params->query_info.status != tabs::TAB_STATUS_NONE;
+  bool loading = params->query_info.status == tabs::TAB_STATUS_LOADING;
 
   URLPatternSet url_patterns;
   if (params->query_info.url.get()) {
     std::vector<std::string> url_pattern_strings;
     if (params->query_info.url->as_string)
       url_pattern_strings.push_back(*params->query_info.url->as_string);
     else if (params->query_info.url->as_strings)
       url_pattern_strings.swap(*params->query_info.url->as_strings);
     // It is o.k. to use URLPattern::SCHEME_ALL here because this function does
     // not grant access to the content of the tabs, only to seeing their URLs
@@ skipping 10 matching lines @@
 
   int window_id = extension_misc::kUnknownWindowId;
   if (params->query_info.window_id.get())
     window_id = *params->query_info.window_id;
 
   int index = -1;
   if (params->query_info.index.get())
     index = *params->query_info.index;
 
   std::string window_type;
-  if (params->query_info.window_type !=
-      tabs::Query::Params::QueryInfo::WINDOW_TYPE_NONE) {
-    window_type = tabs::Query::Params::QueryInfo::ToString(
-        params->query_info.window_type);
-  }
+  if (params->query_info.window_type != tabs::WINDOW_TYPE_NONE)
+    window_type = tabs::ToString(params->query_info.window_type);
 
   base::ListValue* result = new base::ListValue();
   Browser* last_active_browser = chrome::FindAnyBrowser(
       GetProfile(), include_incognito(), chrome::GetActiveDesktop());
   Browser* current_browser = GetCurrentBrowser();
   for (chrome::BrowserIterator it; !it.done(); it.Next()) {
     Browser* browser = *it;
     if (!GetProfile()->IsSameProfile(browser->profile()))
       continue;
 
@@ skipping 1043 matching lines @@
   int tab_id = params->tab_id ? *params->tab_id : -1;
   WebContents* web_contents = GetWebContents(tab_id);
   if (!web_contents)
     return false;
 
   GURL url(web_contents->GetVisibleURL());
   if (PermissionsData::IsRestrictedUrl(url, url, extension(), &error_))
     return false;
 
   // "per-origin" scope is only available in "automatic" mode.
-  if (params->zoom_settings.scope == ZoomSettings::SCOPE_PER_ORIGIN &&
-      params->zoom_settings.mode != ZoomSettings::MODE_AUTOMATIC &&
-      params->zoom_settings.mode != ZoomSettings::MODE_NONE) {
+  if (params->zoom_settings.scope == tabs::ZOOM_SETTINGS_SCOPE_PER_ORIGIN &&
+      params->zoom_settings.mode != tabs::ZOOM_SETTINGS_MODE_AUTOMATIC &&
+      params->zoom_settings.mode != tabs::ZOOM_SETTINGS_MODE_NONE) {
     error_ = keys::kPerOriginOnlyInAutomaticError;
     return false;
   }
 
   // Determine the correct internal zoom mode to set |web_contents| to from the
   // user-specified |zoom_settings|.
   ZoomController::ZoomMode zoom_mode = ZoomController::ZOOM_MODE_DEFAULT;
   switch (params->zoom_settings.mode) {
-    case ZoomSettings::MODE_NONE:
-    case ZoomSettings::MODE_AUTOMATIC:
+    case tabs::ZOOM_SETTINGS_MODE_NONE:
+    case tabs::ZOOM_SETTINGS_MODE_AUTOMATIC:
       switch (params->zoom_settings.scope) {
-        case ZoomSettings::SCOPE_NONE:
-        case ZoomSettings::SCOPE_PER_ORIGIN:
+        case tabs::ZOOM_SETTINGS_SCOPE_NONE:
+        case tabs::ZOOM_SETTINGS_SCOPE_PER_ORIGIN:
           zoom_mode = ZoomController::ZOOM_MODE_DEFAULT;
           break;
-        case ZoomSettings::SCOPE_PER_TAB:
+        case tabs::ZOOM_SETTINGS_SCOPE_PER_TAB:
           zoom_mode = ZoomController::ZOOM_MODE_ISOLATED;
       }
       break;
-    case ZoomSettings::MODE_MANUAL:
+    case tabs::ZOOM_SETTINGS_MODE_MANUAL:
       zoom_mode = ZoomController::ZOOM_MODE_MANUAL;
       break;
-    case ZoomSettings::MODE_DISABLED:
+    case tabs::ZOOM_SETTINGS_MODE_DISABLED:
       zoom_mode = ZoomController::ZOOM_MODE_DISABLED;
   }
 
   ZoomController::FromWebContents(web_contents)->SetZoomMode(zoom_mode);
 
   SendResponse(true);
   return true;
 }
 
 bool TabsGetZoomSettingsFunction::RunAsync() {
@@ skipping 13 matching lines @@
   ZoomModeToZoomSettings(zoom_mode, &zoom_settings);
   zoom_settings.default_zoom_factor.reset(new double(
       content::ZoomLevelToZoomFactor(zoom_controller->GetDefaultZoomLevel())));
 
   results_ = api::tabs::GetZoomSettings::Results::Create(zoom_settings);
   SendResponse(true);
   return true;
 }
 
 }  // namespace extensions