Aura: Support hovering restore & close buttons for full screen apps

chrome/browser/sessions/session_service.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/sessions/session_service.h"
 
 #include <algorithm>
 #include <set>
 #include <utility>
 #include <vector>
@@ skipping 48 matching lines @@
 static const SessionCommand::id_type kCommandSetSelectedNavigationIndex = 7;
 static const SessionCommand::id_type kCommandSetSelectedTabInIndex = 8;
 static const SessionCommand::id_type kCommandSetWindowType = 9;
 // OBSOLETE Superseded by kCommandSetWindowBounds3. Except for data migration.
 // static const SessionCommand::id_type kCommandSetWindowBounds2 = 10;
 static const SessionCommand::id_type
     kCommandTabNavigationPathPrunedFromFront = 11;
 static const SessionCommand::id_type kCommandSetPinnedState = 12;
 static const SessionCommand::id_type kCommandSetExtensionAppID = 13;
 static const SessionCommand::id_type kCommandSetWindowBounds3 = 14;
+static const SessionCommand::id_type kCommandSetWindowAppName = 15;
 
 // Every kWritesPerReset commands triggers recreating the file.
 static const int kWritesPerReset = 250;
 
 namespace {
 
 // The callback from GetLastSession is internally routed to SessionService
 // first and then the caller. This is done so that the SessionWindows can be
 // recreated from the SessionCommands and the SessionWindows passed to the
 // caller. The following class is used for this.
@@ skipping 233 matching lines @@
     // We'll hit this if user closed the last tab in a window.
     has_open_trackable_browsers_ = HasOpenTrackableBrowsers(window_id);
     if (should_record_close_as_pending())
       pending_window_close_ids_.insert(window_id.id());
     else
       ScheduleCommand(CreateWindowClosedCommand(window_id.id()));
   }
 }
 
 void SessionService::SetWindowType(const SessionID& window_id,
-                                   Browser::Type type) {
-  if (!should_track_changes_for_browser_type(type))
+                                   Browser::Type type,
+                                   AppType app_type) {
+  if (!should_track_changes_for_browser_type(type, app_type))
     return;
 
   windows_tracking_.insert(window_id.id());
 
   // The user created a new tabbed browser with our profile. Commit any
   // pending closes.
   CommitPendingCloses();
 
   has_open_trackable_browsers_ = true;
   move_on_new_browser_ = true;
 
   ScheduleCommand(
       CreateSetWindowTypeCommand(window_id, WindowTypeForBrowserType(type)));
 }
 
+void SessionService::SetWindowAppName(
+    const SessionID& window_id,
+    const std::string& app_name) {
+  if (!ShouldTrackChangesToWindow(window_id))
+    return;
+
+  ScheduleCommand(CreateSetTabExtensionAppIDCommand(
+                      kCommandSetWindowAppName,
+                      window_id.id(),
+                      app_name));
+}
+
 void SessionService::TabNavigationPathPrunedFromBack(const SessionID& window_id,
                                                      const SessionID& tab_id,
                                                      int count) {
   if (!ShouldTrackChangesToWindow(window_id))
     return;
 
   TabNavigationPathPrunedFromBackPayload payload = { 0 };
   payload.id = tab_id.id();
   payload.index = count;
   SessionCommand* command =
@@ skipping 114 matching lines @@
   registrar_.Add(this, content::NOTIFICATION_TAB_PARENTED,
                  content::NotificationService::AllSources());
   registrar_.Add(this, content::NOTIFICATION_TAB_CLOSED,
                  content::NotificationService::AllSources());
   registrar_.Add(this, content::NOTIFICATION_NAV_LIST_PRUNED,
                  content::NotificationService::AllSources());
   registrar_.Add(this, content::NOTIFICATION_NAV_ENTRY_CHANGED,
                  content::NotificationService::AllSources());
   registrar_.Add(this, content::NOTIFICATION_NAV_ENTRY_COMMITTED,
                  content::NotificationService::AllSources());
-  registrar_.Add(this, chrome::NOTIFICATION_BROWSER_OPENED,
+  // Wait for NOTIFICATION_BROWSER_WINDOW_READY so that is_app() is set.
+  registrar_.Add(this, chrome::NOTIFICATION_BROWSER_WINDOW_READY,
                  content::NotificationService::AllBrowserContextsAndSources());
   registrar_.Add(
       this, chrome::NOTIFICATION_TAB_CONTENTS_APPLICATION_EXTENSION_CHANGED,
       content::NotificationService::AllSources());
 }
 
 bool SessionService::ShouldNewWindowStartSession() {
   if (!has_open_trackable_browsers_ &&
       !BrowserInit::InSynchronousProfileLaunch() &&
       !SessionRestore::IsRestoring(profile())
@@ skipping 31 matching lines @@
     }
   }
   return false;
 }
 
 void SessionService::Observe(int type,
                              const content::NotificationSource& source,
                              const content::NotificationDetails& details) {
   // All of our messages have the NavigationController as the source.
   switch (type) {
-    case chrome::NOTIFICATION_BROWSER_OPENED: {
+    case chrome::NOTIFICATION_BROWSER_WINDOW_READY: {
       Browser* browser = content::Source<Browser>(source).ptr();
+      AppType app_type = browser->is_app() ? TYPE_APP : TYPE_NORMAL;
       if (browser->profile() != profile() ||
-          !should_track_changes_for_browser_type(browser->type())) {
+          !should_track_changes_for_browser_type(browser->type(), app_type))
         return;
-      }
 
       RestoreIfNecessary(std::vector<GURL>(), browser);
-      SetWindowType(browser->session_id(), browser->type());
+      SetWindowType(browser->session_id(), browser->type(), app_type);
+      SetWindowAppName(browser->session_id(), browser->app_name());
       break;
     }
 
     case content::NOTIFICATION_TAB_PARENTED: {
       TabContentsWrapper* tab =
           content::Source<TabContentsWrapper>(source).ptr();
       if (tab->profile() != profile())
         return;
       SetTabWindow(tab->restore_tab_helper()->window_id(),
                    tab->restore_tab_helper()->session_id());
@@ skipping 335 matching lines @@
                                        const SessionTab* t2) {
   const int delta = t1->tab_visual_index - t2->tab_visual_index;
   return delta == 0 ? (t1->tab_id.id() < t2->tab_id.id()) : (delta < 0);
 }
 
 void SessionService::SortTabsBasedOnVisualOrderAndPrune(
     std::map<int, SessionWindow*>* windows,
     std::vector<SessionWindow*>* valid_windows) {
   std::map<int, SessionWindow*>::iterator i = windows->begin();
   while (i != windows->end()) {
-    if (i->second->tabs.empty() || i->second->is_constrained ||
+    SessionWindow* window = i->second;
+    AppType app_type = window->app_name.empty() ? TYPE_NORMAL : TYPE_APP;
+    if (window->tabs.empty() || window->is_constrained ||
         !should_track_changes_for_browser_type(
-            static_cast<Browser::Type>(i->second->type))) {
-      delete i->second;
+            static_cast<Browser::Type>(window->type),
+            app_type)) {
+      delete window;
       windows->erase(i++);
     } else {
       // Valid window; sort the tabs and add it to the list of valid windows.
-      std::sort(i->second->tabs.begin(), i->second->tabs.end(),
+      std::sort(window->tabs.begin(), window->tabs.end(),
                 &TabVisualIndexSortFunction);
       // Add the window such that older windows appear first.
       if (valid_windows->empty()) {
-        valid_windows->push_back(i->second);
+        valid_windows->push_back(window);
       } else {
         valid_windows->insert(
             std::upper_bound(valid_windows->begin(), valid_windows->end(),
-                             i->second, &WindowOrderSortFunction),
-            i->second);
+                             window, &WindowOrderSortFunction),
+            window);
       }
       ++i;
     }
   }
 }
 
 void SessionService::AddTabsToWindows(std::map<int, SessionTab*>* tabs,
                                       std::map<int, SessionWindow*>* windows) {
   std::map<int, SessionTab*>::iterator i = tabs->begin();
   while (i != tabs->end()) {
@@ skipping 183 matching lines @@
       }
 
       case kCommandSetPinnedState: {
         PinnedStatePayload payload;
         if (!command->GetPayload(&payload, sizeof(payload)))
           return true;
         GetTab(payload.tab_id, tabs)->pinned = payload.pinned_state;
         break;
       }
 
+      case kCommandSetWindowAppName: {
+        SessionID::id_type window_id;
+        std::string app_name;
+        if (!RestoreSetWindowAppNameCommand(*command, &window_id, &app_name))
+          return true;
+
+        GetWindow(window_id, windows)->app_name.swap(app_name);
+        break;
+      }
+
       case kCommandSetExtensionAppID: {
         SessionID::id_type tab_id;
         std::string extension_app_id;
         if (!RestoreSetTabExtensionAppIDCommand(
                 *command, &tab_id, &extension_app_id)) {
           return true;
         }
 
         GetTab(tab_id, tabs)->extension_app_id.swap(extension_app_id);
         break;
@@ skipping 75 matching lines @@
     show_state = ui::SHOW_STATE_MINIMIZED;
 
   commands->push_back(
       CreateSetWindowBoundsCommand(browser->session_id(),
                                    browser->window()->GetRestoredBounds(),
                                    show_state));
 
   commands->push_back(CreateSetWindowTypeCommand(
       browser->session_id(), WindowTypeForBrowserType(browser->type())));
 
+  if (!browser->app_name().empty()) {
+    commands->push_back(CreateSetWindowAppNameCommand(
+        kCommandSetWindowAppName,
+        browser->session_id().id(),
+        browser->app_name()));
+  }
+
   bool added_to_windows_to_track = false;
   for (int i = 0; i < browser->tab_count(); ++i) {
     TabContentsWrapper* tab = browser->GetTabContentsWrapperAt(i);
     DCHECK(tab);
     if (tab->profile() == profile() || profile() == NULL) {
       BuildCommandsForTab(browser->session_id(), tab, i,
                           browser->IsTabPinned(i),
                           commands, tab_to_available_range);
       if (windows_to_track && !added_to_windows_to_track) {
         windows_to_track->insert(browser->session_id().id());
         added_to_windows_to_track = true;
       }
     }
   }
   commands->push_back(
       CreateSetSelectedTabInWindow(browser->session_id(),
                                    browser->active_index()));
 }
 
 void SessionService::BuildCommandsFromBrowsers(
     std::vector<SessionCommand*>* commands,
     IdToRange* tab_to_available_range,
     std::set<SessionID::id_type>* windows_to_track) {
   DCHECK(commands);
   for (BrowserList::const_iterator i = BrowserList::begin();
        i != BrowserList::end(); ++i) {
+    Browser* browser = *i;
     // Make sure the browser has tabs and a window. Browsers destructor
     // removes itself from the BrowserList. When a browser is closed the
     // destructor is not necessarily run immediately. This means its possible
     // for us to get a handle to a browser that is about to be removed. If
     // the tab count is 0 or the window is NULL, the browser is about to be
     // deleted, so we ignore it.
-    if (should_track_changes_for_browser_type((*i)->type()) &&
-        (*i)->tab_count() && (*i)->window()) {
-      BuildCommandsForBrowser(*i, commands, tab_to_available_range,
+    AppType app_type = browser->is_app() ? TYPE_APP : TYPE_NORMAL;
+    if (should_track_changes_for_browser_type(browser->type(), app_type) &&
+        browser->tab_count() &&
+        browser->window()) {
+      BuildCommandsForBrowser(browser, commands, tab_to_available_range,
                               windows_to_track);
     }
   }
 }
 
 void SessionService::ScheduleReset() {
   set_pending_reset(true);
   STLDeleteElements(&pending_commands());
   tab_to_available_range_.clear();
   windows_tracking_.clear();
@@ skipping 86 matching lines @@
 
 bool SessionService::IsOnlyOneTabLeft() {
   if (!profile()) {
     // We're testing, always return false.
     return false;
   }
 
   int window_count = 0;
   for (BrowserList::const_iterator i = BrowserList::begin();
        i != BrowserList::end(); ++i) {
-    const SessionID::id_type window_id = (*i)->session_id().id();
-    if (should_track_changes_for_browser_type((*i)->type()) &&
-        (*i)->profile() == profile() &&
+    Browser* browser = *i;
+    const SessionID::id_type window_id = browser->session_id().id();
+    AppType app_type = browser->is_app() ? TYPE_APP : TYPE_NORMAL;
+    if (should_track_changes_for_browser_type(browser->type(), app_type) &&
+        browser->profile() == profile() &&
         window_closing_ids_.find(window_id) == window_closing_ids_.end()) {
       if (++window_count > 1)
         return false;
       // By the time this is invoked the tab has been removed. As such, we use
       // > 0 here rather than > 1.
       if ((*i)->tab_count() > 0)
         return false;
     }
   }
   return true;
 }
 
 bool SessionService::HasOpenTrackableBrowsers(const SessionID& window_id) {
   if (!profile()) {
     // We're testing, always return false.
     return true;
   }
 
   for (BrowserList::const_iterator i = BrowserList::begin();
        i != BrowserList::end(); ++i) {
     Browser* browser = *i;
     const SessionID::id_type browser_id = browser->session_id().id();
+    AppType app_type = browser->is_app() ? TYPE_APP : TYPE_NORMAL;
     if (browser_id != window_id.id() &&
         window_closing_ids_.find(browser_id) == window_closing_ids_.end() &&
-        should_track_changes_for_browser_type(browser->type()) &&
+        should_track_changes_for_browser_type(browser->type(), app_type) &&
         browser->profile() == profile()) {
       return true;
     }
   }
   return false;
 }
 
 bool SessionService::ShouldTrackChangesToWindow(const SessionID& window_id) {
   return windows_tracking_.find(window_id.id()) != windows_tracking_.end();
 }
 
 
-bool SessionService::should_track_changes_for_browser_type(Browser::Type type) {
+bool SessionService::should_track_changes_for_browser_type(Browser::Type type,
+                                                           AppType app_type) {
+#if defined(USE_AURA)
+  // Restore app popups for aura alone.
+  if (type == Browser::TYPE_POPUP && app_type == TYPE_APP)
+    return true;
+#endif
+
   return type == Browser::TYPE_TABBED ||
         (type == Browser::TYPE_POPUP && browser_defaults::kRestorePopups);
 }
 
 SessionService::WindowType SessionService::WindowTypeForBrowserType(
     Browser::Type type) {
   switch (type) {
     case Browser::TYPE_POPUP:
       return TYPE_POPUP;
     case Browser::TYPE_TABBED:
@@ skipping 136 matching lines @@
       50);
   if (use_long_period) {
     std::string long_name_("SessionRestore.SaveLongPeriod");
     UMA_HISTOGRAM_CUSTOM_TIMES(long_name_,
         delta,
         save_delay_in_mins_,
         save_delay_in_hrs_,
         50);
   }
 }