Move LaunchType out of ExtensionPrefs.

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"
 #include "base/metrics/field_trial.h"
 #include "base/metrics/histogram.h"
 #include "base/strings/utf_string_conversions.h"
 #include "chrome/browser/app_mode/app_mode_utils.h"
 #include "chrome/browser/extensions/extension_prefs.h"
 #include "chrome/browser/extensions/extension_service.h"
 #include "chrome/browser/extensions/extension_system.h"
+#include "chrome/browser/extensions/launch_util.h"
 #include "chrome/browser/extensions/tab_helper.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/signin/signin_manager.h"
 #include "chrome/browser/signin/signin_manager_factory.h"
 #include "chrome/browser/ui/app_list/app_list_service.h"
 #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"
@@ skipping 125 matching lines @@
   }
 
   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.
   ExtensionService* service =
       extensions::ExtensionSystem::Get(profile)->extension_service();
-  ExtensionPrefs::LaunchType launch_type =
-      service->extension_prefs()->GetLaunchType(extension);
-  if (launch_type == ExtensionPrefs::LAUNCH_TYPE_FULLSCREEN)
+  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 == ExtensionPrefs::LAUNCH_TYPE_WINDOW)
+  else if (launch_type == extensions::LAUNCH_TYPE_WINDOW)
     return ui::SHOW_STATE_NORMAL;
 #endif
 
   return ui::SHOW_STATE_DEFAULT;
 }
 
 WebContents* OpenApplicationWindow(const AppLaunchParams& params) {
   Profile* const profile = params.profile;
   const extensions::Extension* const extension = params.extension;
   const GURL url_input = params.override_url;
@@ skipping 66 matching lines @@
     // For existing browser, ensure its window is shown and activated.
     browser->window()->Show();
     browser->window()->Activate();
   }
 
   // Check the prefs for overridden mode.
   ExtensionService* extension_service =
       extensions::ExtensionSystem::Get(profile)->extension_service();
   DCHECK(extension_service);
 
-  ExtensionPrefs::LaunchType launch_type =
-      extension_service->extension_prefs()->GetLaunchType(extension);
+  extensions::LaunchType launch_type = extensions::GetLaunchType(
+      extension_service->extension_prefs(), extension);
   UMA_HISTOGRAM_ENUMERATION("Extensions.AppTabLaunchType", launch_type, 100);
 
   int add_type = TabStripModel::ADD_ACTIVE;
-  if (launch_type == ExtensionPrefs::LAUNCH_TYPE_PINNED)
+  if (launch_type == extensions::LAUNCH_TYPE_PINNED)
     add_type |= TabStripModel::ADD_PINNED;
 
   GURL extension_url = UrlForExtension(extension, launch_params.override_url);
   chrome::NavigateParams params(browser, extension_url,
                                 content::PAGE_TRANSITION_AUTO_TOPLEVEL);
   params.tabstrip_add_types = add_type;
   params.disposition = disposition;
 
   if (disposition == CURRENT_TAB) {
     WebContents* existing_tab =
@@ skipping 21 matching lines @@
     chrome::Navigate(&params);
     contents = params.target_contents;
   }
 
   // On Chrome OS the host desktop type for a browser window is always set to
   // HOST_DESKTOP_TYPE_ASH. On Windows 8 it is only the case for Chrome ASH
   // in metro mode.
   if (browser->host_desktop_type() == chrome::HOST_DESKTOP_TYPE_ASH) {
     // In ash, LAUNCH_FULLSCREEN launches in the OpenApplicationWindow function
     // i.e. it should not reach here.
-    DCHECK(launch_type != ExtensionPrefs::LAUNCH_TYPE_FULLSCREEN);
+    DCHECK(launch_type != extensions::LAUNCH_TYPE_FULLSCREEN);
   } else {
     // TODO(skerner):  If we are already in full screen mode, and the user
     // set the app to open as a regular or pinned tab, what should happen?
     // Today we open the tab, but stay in full screen mode.  Should we leave
     // full screen mode in this case?
-    if (launch_type == ExtensionPrefs::LAUNCH_TYPE_FULLSCREEN &&
+    if (launch_type == extensions::LAUNCH_TYPE_FULLSCREEN &&
         !browser->window()->IsFullscreen()) {
 #if defined(OS_MACOSX)
       chrome::ToggleFullscreenWithChromeOrFallback(browser);
 #else
       chrome::ToggleFullscreenMode(browser);
 #endif
     }
   }
   return contents;
 }
@@ skipping 87 matching lines @@
       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 = service->extension_prefs()->GetLaunchContainer(extension);
+  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),
       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;
   } else if (disposition == NEW_WINDOW) {
     container = extensions::LAUNCH_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 = service->extension_prefs()->GetLaunchContainer(extension);
+    container = extensions::GetLaunchContainer(
+        service->extension_prefs(), extension);
     disposition = NEW_FOREGROUND_TAB;
   }
 }
 
 WebContents* OpenApplication(const AppLaunchParams& params) {
   return OpenEnabledApplication(params);
 }
 
 void OpenApplicationWithReenablePrompt(const AppLaunchParams& params) {
   Profile* profile = params.profile;
@@ skipping 31 matching lines @@
   // 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;
 }