Revert 152221 - chromeos: Sync animation.

chrome/browser/ui/ash/launcher/chrome_launcher_controller.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/ash/launcher/chrome_launcher_controller.h"
 
 #include <set>
 #include <vector>
 
 #include "ash/launcher/launcher_model.h"
 #include "ash/launcher/launcher_types.h"
 #include "ash/shell.h"
 #include "ash/wm/window_util.h"
 #include "base/command_line.h"
 #include "base/utf_string_conversions.h"
 #include "base/values.h"
 #include "chrome/browser/defaults.h"
 #include "chrome/browser/extensions/extension_service.h"
-#include "chrome/browser/extensions/pending_extension_manager.h"
 #include "chrome/browser/prefs/incognito_mode_prefs.h"
 #include "chrome/browser/prefs/pref_service.h"
 #include "chrome/browser/prefs/scoped_user_pref_update.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/profiles/profile_manager.h"
-#include "chrome/browser/sync/profile_sync_service.h"
-#include "chrome/browser/sync/profile_sync_service_factory.h"
 #include "chrome/browser/ui/ash/chrome_launcher_prefs.h"
 #include "chrome/browser/ui/ash/extension_utils.h"
 #include "chrome/browser/ui/ash/launcher/browser_launcher_item_controller.h"
 #include "chrome/browser/ui/ash/launcher/launcher_app_icon_loader.h"
 #include "chrome/browser/ui/ash/launcher/launcher_app_tab_helper.h"
 #include "chrome/browser/ui/ash/launcher/launcher_context_menu.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_window.h"
 #include "chrome/browser/ui/extensions/shell_window.h"
 #include "chrome/browser/ui/tab_contents/tab_contents.h"
 #include "chrome/browser/ui/tabs/tab_strip_model.h"
 #include "chrome/browser/web_applications/web_app.h"
 #include "chrome/common/chrome_notification_types.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/common/extensions/extension.h"
 #include "chrome/common/extensions/extension_resource.h"
 #include "chrome/common/pref_names.h"
 #include "content/public/browser/notification_service.h"
 #include "content/public/browser/web_contents.h"
 #include "grit/theme_resources.h"
 #include "ui/aura/client/activation_client.h"
 #include "ui/aura/window.h"
 #include "ui/views/widget/widget.h"
 
 using extensions::Extension;
 
-namespace {
-
-// Max loading animation time in milliseconds.
-const int kMaxLoadingTimeMs = 60 * 1000;
-
-}  // namespace
-
 // ChromeLauncherController::Item ----------------------------------------------
 
 ChromeLauncherController::Item::Item()
     : item_type(TYPE_TABBED_BROWSER),
       controller(NULL) {
 }
 
 ChromeLauncherController::Item::~Item() {
 }
 
 // ChromeLauncherController ----------------------------------------------------
 
 // static
 ChromeLauncherController* ChromeLauncherController::instance_ = NULL;
 
 ChromeLauncherController::ChromeLauncherController(Profile* profile,
                                                    ash::LauncherModel* model)
     : model_(model),
       profile_(profile),
-      activation_client_(NULL),
-      observed_sync_service_(NULL) {
+      activation_client_(NULL) {
   if (!profile_) {
     // Use the original profile as on chromeos we may get a temporary off the
     // record profile.
     profile_ = ProfileManager::GetDefaultProfile()->GetOriginalProfile();
-
-    // Monitor app sync on chromeos.
-    if (!IsLoggedInAsGuest()) {
-      observed_sync_service_ =
-          ProfileSyncServiceFactory::GetForProfile(profile_);
-      if (observed_sync_service_) {
-        observed_sync_service_->AddObserver(this);
-        StartLoadingAnimation();
-      }
-    }
   }
-
   instance_ = this;
   model_->AddObserver(this);
   extensions::ShellWindowRegistry::Get(profile_)->AddObserver(this);
   app_tab_helper_.reset(new LauncherAppTabHelper(profile_));
   app_icon_loader_.reset(new LauncherAppIconLoader(profile_, this));
 
   notification_registrar_.Add(this,
                               chrome::NOTIFICATION_EXTENSION_LOADED,
                               content::Source<Profile>(profile_));
   notification_registrar_.Add(this,
@@ skipping 17 matching lines @@
   if (activation_client_)
     activation_client_->RemoveObserver(this);
 
   for (WindowToIDMap::iterator i = window_to_id_map_.begin();
        i != window_to_id_map_.end(); ++i) {
     i->first->RemoveObserver(this);
   }
 
   if (ash::Shell::HasInstance())
     ash::Shell::GetInstance()->RemoveShellObserver(this);
-
-  if (observed_sync_service_)
-    observed_sync_service_->RemoveObserver(this);
 }
 
 void ChromeLauncherController::Init() {
   // TODO(xiyuan): Remove migration code and kUseDefaultPinnedApp after M20.
   // Migration cases:
   // - Users that unpin all apps:
   //   - have default pinned apps
   //   - kUseDefaultPinnedApps set to false
   //   Migrate them by setting an empty list for kPinnedLauncherApps.
   //
@@ skipping 132 matching lines @@
 void ChromeLauncherController::Open(ash::LauncherID id, int event_flags) {
   if (id_to_item_map_.find(id) == id_to_item_map_.end())
     return;  // In case invoked from menu and item closed while menu up.
 
   BrowserLauncherItemController* controller = id_to_item_map_[id].controller;
   if (controller) {
     controller->window()->Show();
     ash::wm::ActivateWindow(controller->window());
   } else {
     DCHECK_EQ(TYPE_APP, id_to_item_map_[id].item_type);
+
+    // Do nothing for pending app shortcut.
+    if (GetItemStatus(id) == ash::STATUS_IS_PENDING)
+      return;
+
     OpenAppID(id_to_item_map_[id].app_id, event_flags);
   }
 }
 
 void ChromeLauncherController::OpenAppID(
     const std::string& app_id,
     int event_flags) {
   ash::LauncherID launcher_id = GetLauncherIDForAppID(app_id);
   // Check if this item has any windows in the activation list.
   for (WindowList::const_iterator i = platform_app_windows_.begin();
@@ skipping 325 matching lines @@
       aura::Window* window_to_activate =
           id_to_item_map_[id].controller->window();
       if (window_to_activate && ash::wm::IsActiveWindow(window_to_activate))
         return;
       window_to_activate->Show();
       ash::wm::ActivateWindow(window_to_activate);
     }
   }
 }
 
-void ChromeLauncherController::LauncherStatusChanged() {
-}
-
 void ChromeLauncherController::Observe(
     int type,
     const content::NotificationSource& source,
     const content::NotificationDetails& details) {
   switch (type) {
     case chrome::NOTIFICATION_EXTENSION_LOADED: {
       UpdateAppLaunchersFromPref();
-      CheckAppSync();
       break;
     }
     case chrome::NOTIFICATION_EXTENSION_UNLOADED: {
       const content::Details<extensions::UnloadedExtensionInfo> unload_info(
           details);
       const Extension* extension = unload_info->extension;
-      if (IsAppPinned(extension->id()))
-        DoUnpinAppsWithID(extension->id());
+      if (IsAppPinned(extension->id())) {
+        if (unload_info->reason == extension_misc::UNLOAD_REASON_UPDATE)
+          MarkAppPending(extension->id());
+        else
+          DoUnpinAppsWithID(extension->id());
+      }
       break;
     }
     case chrome::NOTIFICATION_PREF_CHANGED: {
       const std::string& pref_name(
           *content::Details<std::string>(details).ptr());
       if (pref_name == prefs::kPinnedLauncherApps)
         UpdateAppLaunchersFromPref();
       else if (pref_name == prefs::kShelfAlignment)
         SetShelfAlignmentFromPrefs();
       else if (pref_name == prefs::kShelfAutoHideBehavior)
@@ skipping 92 matching lines @@
     case ash::SHELF_ALIGNMENT_LEFT:
       pref_value = ash::kShelfAlignmentLeft;
       break;
     case ash::SHELF_ALIGNMENT_RIGHT:
       pref_value = ash::kShelfAlignmentRight;
       break;
   }
   profile_->GetPrefs()->SetString(prefs::kShelfAlignment, pref_value);
 }
 
-void ChromeLauncherController::OnStateChanged() {
-  DCHECK(observed_sync_service_);
-  CheckAppSync();
-}
-
 void ChromeLauncherController::PersistPinnedState() {
   // It is a coding error to call PersistPinnedState() if the pinned apps are
   // not user-editable. The code should check earlier and not perform any
   // modification actions that trigger persisting the state.
   if (!CanPin()) {
     NOTREACHED() << "Can't pin but pinned state being updated";
     return;
   }
 
   // Set kUseDefaultPinnedApps to false and use pinned apps list from prefs
@@ skipping 36 matching lines @@
 }
 
 ash::LauncherItemStatus ChromeLauncherController::GetItemStatus(
     ash::LauncherID id) const {
   int index = model_->ItemIndexByID(id);
   DCHECK_GE(index, 0);
   const ash::LauncherItem& item = model_->items()[index];
   return item.status;
 }
 
+void ChromeLauncherController::MarkAppPending(const std::string& app_id) {
+  for (IDToItemMap::const_iterator i = id_to_item_map_.begin();
+       i != id_to_item_map_.end(); ++i) {
+    if (i->second.item_type == TYPE_APP && i->second.app_id == app_id) {
+      if (GetItemStatus(i->first) == ash::STATUS_CLOSED)
+        SetItemStatus(i->first, ash::STATUS_IS_PENDING);
+
+      break;
+    }
+  }
+}
+
 void ChromeLauncherController::DoPinAppWithID(const std::string& app_id) {
   // If there is an item, do nothing and return.
   if (IsAppPinned(app_id))
     return;
 
   // Otherwise, create an item for it.
   CreateAppLauncherItem(NULL, app_id, ash::STATUS_CLOSED);
   if (CanPin())
     PersistPinnedState();
 }
@@ skipping 37 matching lines @@
     // delete all app launcher entries in between.
     if (IsAppPinned(*pref_app_id)) {
       for (; index < model_->item_count(); ++index) {
         const ash::LauncherItem& item(model_->items()[index]);
         if (item.type != ash::TYPE_APP_SHORTCUT)
           continue;
 
         IDToItemMap::const_iterator entry(id_to_item_map_.find(item.id));
         if (entry != id_to_item_map_.end() &&
             entry->second.app_id == *pref_app_id) {
+          // Current item will be kept. Reset its pending state and ensure
+          // its icon is loaded since it has to be valid to be in |pinned_apps|.
+          if (item.status == ash::STATUS_IS_PENDING) {
+            SetItemStatus(item.id, ash::STATUS_CLOSED);
+            app_icon_loader_->FetchImage(*pref_app_id);
+          }
+
           ++pref_app_id;
           break;
         } else {
           LauncherItemClosed(item.id);
           --index;
         }
       }
       // If the item wasn't found, that means id_to_item_map_ is out of sync.
       DCHECK(index < model_->item_count());
     } else {
@@ skipping 76 matching lines @@
   } else if (controller->type() ==
              BrowserLauncherItemController::TYPE_APP_PANEL ||
              controller->type() ==
              BrowserLauncherItemController::TYPE_EXTENSION_PANEL) {
     item.type = ash::TYPE_APP_PANEL;
   } else {
     item.type = ash::TYPE_TABBED;
   }
   item.is_incognito = false;
   item.image = Extension::GetDefaultIcon(true);
-
-  TabContents* active_tab = GetLastActiveTabContents(app_id);
-  if (active_tab) {
-    Browser* browser = browser::FindBrowserWithWebContents(
-        active_tab->web_contents());
-    DCHECK(browser);
-    if (browser->window()->IsActive())
-      status = ash::STATUS_ACTIVE;
-    else
-      status = ash::STATUS_RUNNING;
+  if (item.type == ash::TYPE_APP_SHORTCUT &&
+      !app_tab_helper_->IsValidID(app_id)) {
+    item.status = ash::STATUS_IS_PENDING;
+  } else {
+    TabContents* active_tab = GetLastActiveTabContents(app_id);
+    if (active_tab) {
+      Browser* browser = browser::FindBrowserWithWebContents(
+          active_tab->web_contents());
+      DCHECK(browser);
+      if (browser->window()->IsActive())
+        status = ash::STATUS_ACTIVE;
+      else
+        status = ash::STATUS_RUNNING;
+    }
+    item.status = status;
   }
-  item.status = status;
-
   model_->AddAt(index, item);
 
   if (!controller || controller->type() !=
       BrowserLauncherItemController::TYPE_EXTENSION_PANEL) {
-    app_icon_loader_->FetchImage(app_id);
+    if (item.status != ash::STATUS_IS_PENDING)
+      app_icon_loader_->FetchImage(app_id);
   }
-
   return id;
 }
-
-void ChromeLauncherController::CheckAppSync() {
-  if (!observed_sync_service_)
-    return;
-
-  const bool synced = observed_sync_service_->ShouldPushChanges();
-  const bool has_pending_extension = profile_->GetExtensionService()->
-      pending_extension_manager()->HasPendingExtensionFromSync();
-
-  if (synced && !has_pending_extension)
-    StopLoadingAnimation();
-}
-
-void ChromeLauncherController::StartLoadingAnimation() {
-  DCHECK(observed_sync_service_);
-  loading_timer_.Start(
-      FROM_HERE,
-      base::TimeDelta::FromMilliseconds(kMaxLoadingTimeMs),
-      this, &ChromeLauncherController::StopLoadingAnimation);
-  model_->SetStatus(ash::LauncherModel::STATUS_LOADING);
-}
-
-void ChromeLauncherController::StopLoadingAnimation() {
-  DCHECK(observed_sync_service_);
-
-  model_->SetStatus(ash::LauncherModel::STATUS_NORMAL);
-  loading_timer_.Stop();
-  observed_sync_service_->RemoveObserver(this);
-  observed_sync_service_ = NULL;
-}