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

chrome/browser/sessions/tab_restore_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/tab_restore_service.h"
 
 #include <algorithm>
 #include <iterator>
 #include <map>
 
@@ skipping 63 matching lines @@
 //   is written out and followed by n tab closed sequences (as previoulsy
 //   described).
 // . When the user restores an entry a command of type kCommandRestoredEntry
 //   is written.
 static const SessionCommand::id_type kCommandUpdateTabNavigation = 1;
 static const SessionCommand::id_type kCommandRestoredEntry = 2;
 static const SessionCommand::id_type kCommandWindow = 3;
 static const SessionCommand::id_type kCommandSelectedNavigationInTab = 4;
 static const SessionCommand::id_type kCommandPinnedState = 5;
 static const SessionCommand::id_type kCommandSetExtensionAppID = 6;
+static const SessionCommand::id_type kCommandSetWindowAppName = 7;
 
 // Number of entries (not commands) before we clobber the file and write
 // everything.
 static const int kEntriesPerReset = 40;
 
 namespace {
 
 // Payload structures.
 
 typedef int32 RestoredEntryPayload;
@@ skipping 139 matching lines @@
 
   AddEntry(local_tab.release(), true, true);
 }
 
 void TabRestoreService::BrowserClosing(TabRestoreServiceDelegate* delegate) {
   closing_delegates_.insert(delegate);
 
   scoped_ptr<Window> window(new Window());
   window->selected_tab_index = delegate->GetSelectedIndex();
   window->timestamp = TimeNow();
+  window->app_name = delegate->GetAppName();
+
   // Don't use std::vector::resize() because it will push copies of an empty tab
   // into the vector, which will give all tabs in a window the same ID.
   for (int i = 0; i < delegate->GetTabCount(); ++i) {
     window->tabs.push_back(Tab());
   }
   size_t entry_index = 0;
   for (int tab_index = 0; tab_index < delegate->GetTabCount(); ++tab_index) {
     PopulateTab(&(window->tabs[entry_index]),
                 tab_index,
                 delegate,
                 &delegate->GetWebContentsAt(tab_index)->GetController());
     if (window->tabs[entry_index].navigations.empty()) {
       window->tabs.erase(window->tabs.begin() + entry_index);
     } else {
       window->tabs[entry_index].browser_id = delegate->GetSessionID().id();
       entry_index++;
     }
   }
-  if (window->tabs.size() == 1) {
+  if (window->tabs.size() == 1 && window->app_name.empty()) {
     // Short-circuit creating a Window if only 1 tab was present. This fixes
     // http://crbug.com/56744. Copy the Tab because it's owned by an object on
     // the stack.
     AddEntry(new Tab(window->tabs[0]), true, true);
   } else if (!window->tabs.empty()) {
     window->selected_tab_index =
         std::min(static_cast<int>(window->tabs.size() - 1),
                  window->selected_tab_index);
     AddEntry(window.release(), true, true);
   }
@@ skipping 70 matching lines @@
     delegate = RestoreTab(*tab, delegate, disposition);
     delegate->ShowBrowserWindow();
   } else if (entry->type == WINDOW) {
     TabRestoreServiceDelegate* current_delegate = delegate;
     Window* window = static_cast<Window*>(entry);
 
     // When restoring a window, either the entire window can be restored, or a
     // single tab within it. If the entry's ID matches the one to restore, then
     // the entire window will be restored.
     if (!restoring_tab_in_window) {
-      delegate = TabRestoreServiceDelegate::Create(profile());
+      delegate = TabRestoreServiceDelegate::Create(profile(), window->app_name);
       for (size_t tab_i = 0; tab_i < window->tabs.size(); ++tab_i) {
         const Tab& tab = window->tabs[tab_i];
         WebContents* restored_tab =
             delegate->AddRestoredTab(tab.navigations, delegate->GetTabCount(),
                                      tab.current_navigation_index,
                                      tab.extension_app_id,
                                      static_cast<int>(tab_i) ==
                                          window->selected_tab_index,
                                      tab.pinned, tab.from_last_session,
                                      tab.session_storage_namespace);
@@ skipping 242 matching lines @@
   }
   if (valid_tab_count == 0)
     return;  // No tabs to persist.
 
   ScheduleCommand(
       CreateWindowCommand(window.id,
                           std::min(real_selected_tab, valid_tab_count - 1),
                           valid_tab_count,
                           window.timestamp));
 
+  if (!window.app_name.empty()) {
+    ScheduleCommand(
+        CreateSetWindowAppNameCommand(kCommandSetWindowAppName,
+                                      window.id,
+                                      window.app_name));
+  }
+
   for (size_t i = 0; i < window.tabs.size(); ++i) {
     int selected_index = GetSelectedNavigationIndexToPersist(window.tabs[i]);
     if (selected_index != -1)
       ScheduleCommandsForTab(window.tabs[i], selected_index);
   }
 }
 
 void TabRestoreService::ScheduleCommandsForTab(const Tab& tab,
                                                int selected_index) {
   const std::vector<TabNavigation>& navigations = tab.navigations;
@@ skipping 254 matching lines @@
         if (!current_tab) {
           // Should be in a tab when we get this.
           return;
         }
         // NOTE: payload doesn't matter. kCommandPinnedState is only written if
         // tab is pinned.
         current_tab->pinned = true;
         break;
       }
 
+      case kCommandSetWindowAppName: {
+        if (!current_window) {
+          // We should have created a window already.
+          NOTREACHED();
+          return;
+        }
+
+        SessionID::id_type window_id;
+        std::string app_name;
+        if (!RestoreSetWindowAppNameCommand(command, &window_id, &app_name))
+          return;
+
+        current_window->app_name.swap(app_name);
+        break;
+      }
+
       case kCommandSetExtensionAppID: {
         if (!current_tab) {
           // Should be in a tab when we get this.
           return;
         }
         SessionID::id_type tab_id;
         std::string extension_app_id;
         if (!RestoreSetTabExtensionAppIDCommand(command, &tab_id,
                                                 &extension_app_id)) {
           return;
@@ skipping 30 matching lines @@
       delegate = TabRestoreServiceDelegate::FindDelegateWithID(tab.browser_id);
 
     int tab_index = -1;
 
     // |delegate| will be NULL in cases where one isn't already available (eg,
     // when invoked on Mac OS X with no windows open). In this case, create a
     // new browser into which we restore the tabs.
     if (delegate && disposition != NEW_WINDOW) {
       tab_index = tab.tabstrip_index;
     } else {
-      delegate = TabRestoreServiceDelegate::Create(profile());
+      delegate = TabRestoreServiceDelegate::Create(profile(), std::string());
       if (tab.has_browser())
         UpdateTabBrowserIDs(tab.browser_id, delegate->GetSessionID().id());
     }
 
     // Place the tab at the end if the tab index is no longer valid or
     // we were passed a specific disposition.
     if (tab_index < 0 || tab_index > delegate->GetTabCount() ||
         disposition != UNKNOWN) {
       tab_index = delegate->GetTabCount();
     }
@@ skipping 219 matching lines @@
   // the front, not the end and we just added the entries to the end).
   entries_to_write_ = staging_entries_.size();
 
   PruneEntries();
   NotifyTabsChanged();
 }
 
 Time TabRestoreService::TimeNow() const {
   return time_factory_ ? time_factory_->TimeNow() : Time::Now();
 }