MacViews: tryjobs for toolkit_views=1

chrome/browser/ui/app_list/app_list_service_mac.mm

 // Copyright 2013 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.
 
 #import "chrome/browser/ui/app_list/app_list_service_mac.h"
 
 #include <ApplicationServices/ApplicationServices.h>
 #import <Cocoa/Cocoa.h>
 
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/files/file_util.h"
 #include "base/lazy_instance.h"
 #include "base/memory/singleton.h"
 #include "base/message_loop/message_loop.h"
 #include "base/prefs/pref_service.h"
 #import "chrome/browser/app_controller_mac.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/extensions/extension_service.h"
 #include "chrome/browser/profiles/profile_info_cache.h"
 #include "chrome/browser/profiles/profile_manager.h"
-#include "chrome/browser/ui/app_list/app_list_controller_delegate_impl.h"
 #include "chrome/browser/ui/app_list/app_list_positioner.h"
 #include "chrome/browser/ui/app_list/app_list_service.h"
+#include "chrome/browser/ui/app_list/app_list_service_cocoa_mac.h"
 #include "chrome/browser/ui/app_list/app_list_service_impl.h"
 #include "chrome/browser/ui/app_list/app_list_util.h"
-#include "chrome/browser/ui/app_list/app_list_view_delegate.h"
 #include "chrome/browser/ui/browser_commands.h"
 #include "chrome/browser/ui/extensions/application_launch.h"
 #include "chrome/browser/web_applications/web_app.h"
 #include "chrome/browser/web_applications/web_app_mac.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/common/chrome_version_info.h"
 #include "chrome/common/extensions/manifest_handlers/app_launch_info.h"
 #include "chrome/common/mac/app_mode_common.h"
 #include "chrome/common/pref_names.h"
 #include "chrome/grit/google_chrome_strings.h"
 #include "content/public/browser/browser_thread.h"
 #include "extensions/browser/extension_system.h"
 #include "extensions/common/manifest_handlers/file_handler_info.h"
 #include "grit/chrome_unscaled_resources.h"
 #include "net/base/url_util.h"
-#import "ui/app_list/cocoa/app_list_view_controller.h"
-#import "ui/app_list/cocoa/app_list_window_controller.h"
+#include "ui/app_list/app_list_switches.h"
 #include "ui/app_list/search_box_model.h"
 #include "ui/base/l10n/l10n_util.h"
 #include "ui/base/resource/resource_bundle.h"
 #include "ui/gfx/display.h"
 #include "ui/gfx/screen.h"
 
+#if defined(TOOLKIT_VIEWS)
+#include "chrome/browser/ui/app_list/app_list_service_views_mac.h"
+#endif
+
 namespace gfx {
 class ImageSkia;
 }
 
 // Controller for animations that show or hide the app list.
 @interface AppListAnimationController : NSObject<NSAnimationDelegate> {
  @private
   // When closing, the window to close. Retained until the animation ends.
   base::scoped_nsobject<NSWindow> window_;
   // The animation started and owned by |self|. Reset when the animation ends.
@@ skipping 192 matching lines @@
       NSMaxY([[[NSScreen screens] objectAtIndex:0] frame]);
   AppListServiceMac::FindAnchorPoint(window_size,
                                      display,
                                      primary_display_height,
                                      cursor_is_visible,
                                      cursor,
                                      target_origin,
                                      start_origin);
 }
 
+AppListServiceMac* GetActiveInstance() {
+  if (app_list::switches::IsMacViewsAppListListEnabled()) {
+#if defined(TOOLKIT_VIEWS)
+    return AppListServiceViewsMac::GetInstance();
+#else
+    NOTREACHED();
+#endif
+  }
+  return AppListServiceCocoaMac::GetInstance();
+}
+
 }  // namespace
 
-AppListServiceMac::AppListServiceMac()
-    : profile_(NULL),
-      controller_delegate_(new AppListControllerDelegateImpl(this)) {
+AppListServiceMac::AppListServiceMac() {
   animation_controller_.reset([[AppListAnimationController alloc] init]);
 }
 
 AppListServiceMac::~AppListServiceMac() {}
 
 // static
-AppListServiceMac* AppListServiceMac::GetInstance() {
-  return Singleton<AppListServiceMac,
-                   LeakySingletonTraits<AppListServiceMac> >::get();
-}
-
-// static
 void AppListServiceMac::FindAnchorPoint(const gfx::Size& window_size,
                                         const gfx::Display& display,
                                         int primary_display_height,
                                         bool cursor_is_visible,
                                         const gfx::Point& cursor,
                                         NSPoint* target_origin,
                                         NSPoint* start_origin) {
   AppListPositioner positioner(display, window_size, 0);
   AppListPositioner::ScreenEdge dock_location = DockLocationInDisplay(display);
 
@@ skipping 72 matching lines @@
       if (kShortcutVersion > installed_shortcut_version)
         CreateShortcut();
     }
   }
 
   static bool init_called = false;
   if (init_called)
     return;
 
   init_called = true;
-  apps::AppShimHandler::RegisterHandler(app_mode::kAppListModeId,
-                                        AppListServiceMac::GetInstance());
+  apps::AppShimHandler::RegisterHandler(app_mode::kAppListModeId, this);
 
   // Handle the case where Chrome was not running and was started with the app
   // launcher shim. The profile has not yet been loaded. To improve response
   // times, start animating an empty window which will be populated via
   // OnShimLaunch(). Note that if --silent-launch is not also passed, the window
   // will instead populate via StartupBrowserCreator::Launch(). Shim-initiated
   // launches will always have --silent-launch.
   if (base::CommandLine::ForCurrentProcess()->
       HasSwitch(switches::kShowAppList)) {
     // Do not show the launcher window when the profile is locked.
     const ProfileInfoCache& profile_info_cache =
         g_browser_process->profile_manager()->GetProfileInfoCache();
     size_t profile_index = profile_info_cache.
         GetIndexOfProfileWithPath(profile_path);
     if (profile_index != std::string::npos &&
-        !profile_info_cache.ProfileIsSigninRequiredAtIndex(profile_index))
+        !profile_info_cache.ProfileIsSigninRequiredAtIndex(profile_index) &&
+        ReadyToShow())
       ShowWindowNearDock();
   }
 }
 
-Profile* AppListServiceMac::GetCurrentAppListProfile() {
-  return profile_;
-}
-
-void AppListServiceMac::ShowForProfile(Profile* requested_profile) {
-  CreateForProfile(requested_profile);
-  ShowWindowNearDock();
-}
-
 void AppListServiceMac::DismissAppList() {
   if (!IsAppListVisible())
     return;
 
+  NSWindow* app_list_window = GetNativeWindow();
   // If the app list is currently the main window, it will activate the next
   // Chrome window when dismissed. But if a different application was active
   // when the app list was shown, activate that instead.
   base::scoped_nsobject<NSRunningApplication> prior_app;
-  if ([[window_controller_ window] isMainWindow])
+  if ([app_list_window isMainWindow])
     prior_app.swap(previously_active_application_);
   else
     previously_active_application_.reset();
 
   // If activation is successful, the app list will lose main status and try to
   // close itself again. It can't be closed in this runloop iteration without
   // OSX deciding to raise the next Chrome window, and _then_ activating the
   // application on top. This also occurs if no activation option is given.
   if ([prior_app activateWithOptions:NSApplicationActivateIgnoringOtherApps])
     return;
 
-  [animation_controller_ animateWindow:[window_controller_ window]
+  [animation_controller_ animateWindow:app_list_window
                           targetOrigin:last_start_origin_
                                closing:YES];
 }
 
 void AppListServiceMac::ShowForCustomLauncherPage(Profile* profile) {
   NOTIMPLEMENTED();
 }
 
 bool AppListServiceMac::IsAppListVisible() const {
-  return [[window_controller_ window] isVisible] &&
+  return [GetNativeWindow() isVisible] &&
       ![animation_controller_ isClosing];
 }
 
 void AppListServiceMac::EnableAppList(Profile* initial_profile,
                                       AppListEnableSource enable_source) {
   AppListServiceImpl::EnableAppList(initial_profile, enable_source);
   AppController* controller = [NSApp delegate];
   [controller initAppShimMenuController];
 }
 
 void AppListServiceMac::CreateShortcut() {
   CreateAppListShim(GetProfilePath(
       g_browser_process->profile_manager()->user_data_dir()));
 }
 
-void AppListServiceMac::CreateForProfile(Profile* requested_profile) {
-  DCHECK(requested_profile);
-  InvalidatePendingProfileLoads();
-  if (profile_ && requested_profile->IsSameProfile(profile_))
-    return;
-
-  profile_ = requested_profile->GetOriginalProfile();
-  SetProfilePath(profile_->GetPath());
-
-  if (!window_controller_)
-    window_controller_.reset([[AppListWindowController alloc] init]);
-
-  [[window_controller_ appListViewController] setDelegate:nil];
-  [[window_controller_ appListViewController]
-      setDelegate:GetViewDelegate(profile_)];
-}
-
-void AppListServiceMac::DestroyAppList() {
-  // Due to reference counting, Mac can't guarantee that the widget is deleted,
-  // but mac supports a visible app list with a NULL profile, so there's also no
-  // need to tear it down completely.
-  DismissAppList();
-  [[window_controller_ appListViewController] setDelegate:NULL];
-
-  profile_ = NULL;
-}
-
 NSWindow* AppListServiceMac::GetAppListWindow() {
-  return [window_controller_ window];
-}
-
-AppListControllerDelegate* AppListServiceMac::GetControllerDelegate() {
-  return controller_delegate_.get();
+  return GetNativeWindow();
 }
 
 void AppListServiceMac::OnShimLaunch(apps::AppShimHandler::Host* host,
                                      apps::AppShimLaunchType launch_type,
                                      const std::vector<base::FilePath>& files) {
-  if (profile_ && IsAppListVisible()) {
+  if (GetCurrentAppListProfile() && IsAppListVisible()) {
     DismissAppList();
   } else {
     // Start by showing a possibly empty window to handle the case where Chrome
     // is running, but hasn't yet loaded the app launcher profile.
-    ShowWindowNearDock();
+    if (ReadyToShow())
+      ShowWindowNearDock();
     Show();
   }
 
   // Always close the shim process immediately.
   host->OnAppLaunchComplete(apps::APP_SHIM_LAUNCH_DUPLICATE_HOST);
 }
 
 void AppListServiceMac::OnShimClose(apps::AppShimHandler::Host* host) {}
 
 void AppListServiceMac::OnShimFocus(apps::AppShimHandler::Host* host,
                                     apps::AppShimFocusType focus_type,
                                     const std::vector<base::FilePath>& files) {}
 
 void AppListServiceMac::OnShimSetHidden(apps::AppShimHandler::Host* host,
                                         bool hidden) {}
 
 void AppListServiceMac::OnShimQuit(apps::AppShimHandler::Host* host) {}
 
 void AppListServiceMac::ShowWindowNearDock() {
   if (IsAppListVisible())
     return;
 
-  if (!window_controller_) {
-    // Note that this will start showing an unpopulated window, the caller needs
-    // to ensure it will be populated later.
-    window_controller_.reset([[AppListWindowController alloc] init]);
-  }
-
   NSWindow* window = GetAppListWindow();
   DCHECK(window);
   NSPoint target_origin;
   GetAppListWindowOrigins(window, &target_origin, &last_start_origin_);
   [window setFrameOrigin:last_start_origin_];
 
   // Before activating, see if an application other than Chrome is currently the
   // active application, so that it can be reactivated when dismissing.
   previously_active_application_.reset([ActiveApplicationNotChrome() retain]);
 
-  [animation_controller_ animateWindow:[window_controller_ window]
+  [animation_controller_ animateWindow:window
                           targetOrigin:target_origin
                                closing:NO];
   [window makeKeyAndOrderFront:nil];
   [NSApp activateIgnoringOtherApps:YES];
   RecordAppListLaunch();
 }
 
 void AppListServiceMac::WindowAnimationDidEnd() {
   [animation_controller_ cleanupOnUIThread];
 }
 
 // static
 AppListService* AppListService::Get(chrome::HostDesktopType desktop_type) {
-  return AppListServiceMac::GetInstance();
+  return GetActiveInstance();
 }
 
 // static
 void AppListService::InitAll(Profile* initial_profile,
                              const base::FilePath& profile_path) {
-  AppListServiceMac::GetInstance()->InitWithProfilePath(initial_profile,
-                                                        profile_path);
+  GetActiveInstance()->InitWithProfilePath(initial_profile, profile_path);
 }
 
 @implementation AppListAnimationController
 
 - (BOOL)isClosing {
   return !!window_;
 }
 
 - (void)animateWindow:(NSWindow*)window
          targetOrigin:(NSPoint)targetOrigin
@@ skipping 47 matching lines @@
 
   if (closing)
     apps::AppShimHandler::MaybeTerminate();
 }
 
 - (void)animationDidEnd:(NSAnimation*)animation {
   content::BrowserThread::PostTask(
       content::BrowserThread::UI,
       FROM_HERE,
       base::Bind(&AppListServiceMac::WindowAnimationDidEnd,
-                 base::Unretained(AppListServiceMac::GetInstance())));
+                 base::Unretained(GetActiveInstance())));
 }
 
 @end