Move LaunchContainer enum to extension_constants.h.

chrome/browser/ui/extensions/application_launch.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/ui/extensions/application_launch.h"
 
 #include <string>
 
 #include "apps/launcher.h"
 #include "base/command_line.h"
@@ skipping 13 matching lines @@
 #include "chrome/browser/ui/browser.h"
 #include "chrome/browser/ui/browser_commands.h"
 #include "chrome/browser/ui/browser_finder.h"
 #include "chrome/browser/ui/browser_tabstrip.h"
 #include "chrome/browser/ui/browser_window.h"
 #include "chrome/browser/ui/extensions/extension_enable_flow.h"
 #include "chrome/browser/ui/extensions/extension_enable_flow_delegate.h"
 #include "chrome/browser/ui/tabs/tab_strip_model.h"
 #include "chrome/browser/web_applications/web_app.h"
 #include "chrome/common/chrome_switches.h"
+#include "chrome/common/extensions/extension_constants.h"
 #include "chrome/common/extensions/manifest_handlers/app_launch_info.h"
 #include "chrome/common/extensions/manifest_url_handler.h"
 #include "chrome/common/url_constants.h"
 #include "content/public/browser/render_view_host.h"
 #include "content/public/browser/web_contents.h"
 #include "content/public/browser/web_contents_view.h"
 #include "content/public/common/renderer_preferences.h"
 #include "extensions/common/constants.h"
 #include "extensions/common/extension.h"
 #include "grit/generated_resources.h"
@@ skipping 97 matching lines @@
       url = GURL(chrome::kChromeUIExtensionsURL);
   }
 
   return url;
 }
 
 ui::WindowShowState DetermineWindowShowState(
     Profile* profile,
     extensions::LaunchContainer container,
     const Extension* extension) {
-  if (!extension ||
-      container != extensions::LAUNCH_WINDOW) {
+  if (!extension || container != extensions::LAUNCH_CONTAINER_WINDOW)
     return ui::SHOW_STATE_DEFAULT;
-  }
 
   if (chrome::IsRunningInForcedAppMode())
     return ui::SHOW_STATE_FULLSCREEN;
 
 #if defined(USE_ASH)
-  // In ash, LAUNCH_FULLSCREEN launches in a maximized app window and
-  // LAUNCH_WINDOW launches in a normal app window.
+  // In ash, LAUNCH_TYPE_FULLSCREEN launches in a maximized app window and
+  // LAUNCH_TYPE_WINDOW launches in a normal app window.
   ExtensionService* service =
       extensions::ExtensionSystem::Get(profile)->extension_service();
   extensions::LaunchType launch_type = extensions::GetLaunchType(
       service->extension_prefs(), extension);
   if (launch_type == extensions::LAUNCH_TYPE_FULLSCREEN)
     return ui::SHOW_STATE_MAXIMIZED;
   else if (launch_type == extensions::LAUNCH_TYPE_WINDOW)
     return ui::SHOW_STATE_NORMAL;
 #endif
 
@@ skipping 183 matching lines @@
     apps::LaunchPlatformAppWithCommandLine(
         profile, extension, params.command_line, params.current_directory);
     return NULL;
   }
 
   // Record v1 app launch. Platform app launch is recorded when dispatching
   // the onLaunched event.
   prefs->SetLastLaunchTime(extension->id(), base::Time::Now());
 
   switch (params.container) {
-    case extensions::LAUNCH_NONE: {
+    case extensions::LAUNCH_CONTAINER_NONE: {
       NOTREACHED();
       break;
     }
-    case extensions::LAUNCH_PANEL:
-    case extensions::LAUNCH_WINDOW:
+    case extensions::LAUNCH_CONTAINER_PANEL:
+    case extensions::LAUNCH_CONTAINER_WINDOW:
       tab = OpenApplicationWindow(params);
       break;
-    case extensions::LAUNCH_TAB: {
+    case extensions::LAUNCH_CONTAINER_TAB: {
       tab = OpenApplicationTab(params);
       break;
     }
     default:
       NOTREACHED();
       break;
   }
   return tab;
 }
 
@@ skipping 10 matching lines @@
       desktop_type(chrome::GetActiveDesktop()),
       override_url(),
       override_bounds(),
       command_line(NULL) {}
 
 AppLaunchParams::AppLaunchParams(Profile* profile,
                                  const extensions::Extension* extension,
                                  WindowOpenDisposition disposition)
     : profile(profile),
       extension(extension),
-      container(extensions::LAUNCH_NONE),
+      container(extensions::LAUNCH_CONTAINER_NONE),
       disposition(disposition),
       desktop_type(chrome::GetActiveDesktop()),
       override_url(),
       override_bounds(),
       command_line(NULL) {
   ExtensionService* service =
       extensions::ExtensionSystem::Get(profile)->extension_service();
   DCHECK(service);
 
   // Look up the app preference to find out the right launch container. Default
   // is to launch as a regular tab.
   container = extensions::GetLaunchContainer(
       service->extension_prefs(), extension);
 }
 
 AppLaunchParams::AppLaunchParams(Profile* profile,
                                  const extensions::Extension* extension,
                                  int event_flags,
                                  chrome::HostDesktopType desktop_type)
     : profile(profile),
       extension(extension),
-      container(extensions::LAUNCH_NONE),
+      container(extensions::LAUNCH_CONTAINER_NONE),
       disposition(ui::DispositionFromEventFlags(event_flags)),
       desktop_type(desktop_type),
       override_url(),
       override_bounds(),
       command_line(NULL) {
   if (disposition == NEW_FOREGROUND_TAB || disposition == NEW_BACKGROUND_TAB) {
-    container = extensions::LAUNCH_TAB;
+    container = extensions::LAUNCH_CONTAINER_TAB;
   } else if (disposition == NEW_WINDOW) {
-    container = extensions::LAUNCH_WINDOW;
+    container = extensions::LAUNCH_CONTAINER_WINDOW;
   } else {
     ExtensionService* service =
         extensions::ExtensionSystem::Get(profile)->extension_service();
     DCHECK(service);
 
     // Look at preference to find the right launch container.  If no preference
     // is set, launch as a regular tab.
     container = extensions::GetLaunchContainer(
         service->extension_prefs(), extension);
     disposition = NEW_FOREGROUND_TAB;
@@ skipping 19 matching lines @@
 
   OpenEnabledApplication(params);
 }
 
 WebContents* OpenAppShortcutWindow(Profile* profile,
                                    const GURL& url,
                                    const gfx::Rect& override_bounds) {
   AppLaunchParams launch_params(
       profile,
       NULL,  // this is a URL app.  No extension.
-      extensions::LAUNCH_WINDOW,
+      extensions::LAUNCH_CONTAINER_WINDOW,
       NEW_WINDOW);
   launch_params.override_url = url;
   launch_params.override_bounds = override_bounds;
 
   WebContents* tab = OpenApplicationWindow(launch_params);
 
   if (!tab)
     return NULL;
 
   // Set UPDATE_SHORTCUT as the pending web app action. This action is picked
   // up in LoadingStateChanged to schedule a GetApplicationInfo. And when
   // the web app info is available, extensions::TabHelper notifies Browser via
   // OnDidGetApplicationInfo, which calls
   // web_app::UpdateShortcutForTabContents when it sees UPDATE_SHORTCUT as
   // pending web app action.
   extensions::TabHelper::FromWebContents(tab)->set_pending_web_app_action(
       extensions::TabHelper::UPDATE_SHORTCUT);
 
   return tab;
 }