Reland 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/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/ash/launcher/launcher_item_controller.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) {
+      activation_client_(NULL),
+      observed_sync_service_(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);
+    }
   }
+
   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 131 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.
 
   LauncherItemController* controller = id_to_item_map_[id].controller;
   if (controller) {
     controller->Open();
   } 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 307 matching lines @@
     int index,
     const ash::LauncherItem& old_item) {
   if (model_->items()[index].status == ash::STATUS_ACTIVE &&
       old_item.status == ash::STATUS_RUNNING) {
     ash::LauncherID id = model_->items()[index].id;
     if (id_to_item_map_[id].controller)
       id_to_item_map_[id].controller->Open();
   }
 }
 
+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())) {
-        if (unload_info->reason == extension_misc::UNLOAD_REASON_UPDATE)
-          MarkAppPending(extension->id());
-        else
-          DoUnpinAppsWithID(extension->id());
-      }
+      if (IsAppPinned(extension->id()))
+        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 75 matching lines @@
       item.type = ash::TYPE_PLATFORM_APP;
   } else if (controller->type() == LauncherItemController::TYPE_APP_PANEL ||
              controller->type() ==
              LauncherItemController::TYPE_EXTENSION_PANEL) {
     item.type = ash::TYPE_APP_PANEL;
   } else {
     item.type = ash::TYPE_TABBED;
   }
   item.is_incognito = false;
   item.image = Extension::GetDefaultIcon(true);
-  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;
+
+  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;
+
   model_->AddAt(index, item);
 
   if (!controller ||
       controller->type() != LauncherItemController::TYPE_EXTENSION_PANEL) {
-    if (item.status != ash::STATUS_IS_PENDING)
-      app_icon_loader_->FetchImage(app_id);
+    app_icon_loader_->FetchImage(app_id);
   }
   return id;
 }
+
+void ChromeLauncherController::CheckAppSync() {
+  if (!observed_sync_service_ ||
+      !observed_sync_service_->HasSyncSetupCompleted()) {
+    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();
+  else
+    StartLoadingAnimation();
+}
+
+void ChromeLauncherController::StartLoadingAnimation() {
+  DCHECK(observed_sync_service_);
+  if (model_->status() == ash::LauncherModel::STATUS_LOADING)
+    return;
+
+  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;
+}