Changes tab restore service to handle restoring closed windows as a...

chrome/browser/dom_ui/new_tab_ui.cc

 // Copyright (c) 2006-2008 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/dom_ui/new_tab_ui.h"
 
 #include "base/histogram.h"
 #include "base/string_piece.h"
 #include "chrome/app/locales/locale_settings.h"
 #include "chrome/browser/browser.h"
@@ skipping 626 matching lines @@
   if (content->GetType() == Value::TYPE_LIST) {
     const ListValue* list_value = static_cast<const ListValue*>(content);
     Value* list_member;
     if (list_value->Get(0, &list_member) &&
         list_member->GetType() == Value::TYPE_STRING) {
       const StringValue* string_value =
           static_cast<const StringValue*>(list_member);
       std::wstring wstring_value;
       if (string_value->GetAsString(&wstring_value)) {
         int session_to_restore = _wtoi(wstring_value.c_str());
-
-        const TabRestoreService::Tabs& tabs = tab_restore_service_->tabs();
-        for (TabRestoreService::Tabs::const_iterator it = tabs.begin();
-             it != tabs.end(); ++it) {
-          if (it->id == session_to_restore) {
-            TabRestoreService* tab_restore_service = tab_restore_service_;
-            browser->ReplaceRestoredTab(
-                 it->navigations, it->current_navigation_index);
-            tab_restore_service->RemoveHistoricalTabById(session_to_restore);
-            // The current tab has been nuked at this point;
-            // don't touch any member variables.
-            break;
-          }
-        }
+        tab_restore_service_->RestoreEntryById(browser, session_to_restore,
+                                               true);
+        // The current tab has been nuked at this point; don't touch any member
+        // variables.
       }
     }
   }
 }
 
 void RecentlyClosedTabsHandler::HandleGetRecentlyClosedTabs(
     const Value* content) {
   if (!tab_restore_service_) {
     tab_restore_service_ = dom_ui_host_->profile()->GetTabRestoreService();
 
     // GetTabRestoreService() can return NULL (i.e., when in Off the
     // Record mode)
     if (tab_restore_service_)
       tab_restore_service_->AddObserver(this);
   }
 
   if (tab_restore_service_)
     TabRestoreServiceChanged(tab_restore_service_);
 }
 
 void RecentlyClosedTabsHandler::TabRestoreServiceChanged(
     TabRestoreService* service) {
-  const TabRestoreService::Tabs& tabs = service->tabs();
+  const TabRestoreService::Entries& entries = service->entries();
   ListValue list_value;
   int added_count = 0;
 
-  // We filter the list of recently closed to only show 'interesting' tabs,
-  // where an interesting tab navigation is not the new tab ui.
-  for (TabRestoreService::Tabs::const_iterator it = tabs.begin();
-       it != tabs.end() && added_count < 3; ++it) {
-    if (it->navigations.empty())
-      continue;
-
-    const TabNavigation& navigator =
-        it->navigations.at(it->current_navigation_index);
-    if (navigator.url == NewTabUIURL())
-      continue;
-
-    DictionaryValue* dictionary = new DictionaryValue;
-    SetURLAndTitle(dictionary, navigator.title, navigator.url);
-    dictionary->SetInteger(L"sessionId", it->id);
-
-    list_value.Append(dictionary);
-    added_count++;
+  // We filter the list of recently closed to only show 'interesting' entries,
+  // where an interesting entry is either a closed window or a closed tab
+  // whose selected navigation is not the new tab ui.
+  for (TabRestoreService::Entries::const_iterator it = entries.begin();
+       it != entries.end() && added_count < 3; ++it) {
+    TabRestoreService::Entry* entry = *it;
+    DictionaryValue* value = new DictionaryValue();
+    if ((entry->type == TabRestoreService::TAB &&
+         TabToValue(*static_cast<TabRestoreService::Tab*>(entry), value)) ||
+        (entry->type == TabRestoreService::WINDOW &&
+         WindowToValue(*static_cast<TabRestoreService::Window*>(entry),
+                       value))) {
+      value->SetInteger(L"sessionId", entry->id);
+      list_value.Append(value);
+      added_count++;
+    } else {
+      delete value;
+    }
   }
   dom_ui_host_->CallJavascriptFunction(L"recentlyClosedTabs", list_value);
 }
 
 void RecentlyClosedTabsHandler::TabRestoreServiceDestroyed(
     TabRestoreService* service) {
   tab_restore_service_ = NULL;
 }
 
+bool RecentlyClosedTabsHandler::TabToValue(
+    const TabRestoreService::Tab& tab,
+    DictionaryValue* dictionary) {
+  if (tab.navigations.empty())
+    return false;
+
+  const TabNavigation& current_navigation =
+      tab.navigations.at(tab.current_navigation_index);
+  if (current_navigation.url == NewTabUIURL())
+    return false;
+
+  SetURLAndTitle(dictionary, current_navigation.title, current_navigation.url);
+  dictionary->SetString(L"type", L"tab");
+  return true;
+}
+
+bool RecentlyClosedTabsHandler::WindowToValue(
+    const TabRestoreService::Window& window,
+    DictionaryValue* dictionary) {
+  if (window.tabs.empty()) {
+    NOTREACHED();
+    return false;
+  }
+
+  ListValue* tab_values = new ListValue();
+  for (size_t i = 0; i < window.tabs.size(); ++i) {
+    DictionaryValue* tab_value = new DictionaryValue();
+    if (TabToValue(window.tabs[i], tab_value))
+      tab_values->Append(tab_value);
+    else
+      delete tab_value;
+  }
+  if (tab_values->GetSize() == 0) {
+    delete tab_values;
+    return false;
+  }
+
+  dictionary->SetString(L"type", L"window");
+  dictionary->Set(L"tabs", tab_values);
+  return true;
+}
+
 ///////////////////////////////////////////////////////////////////////////////
 // HistoryHandler
 
 HistoryHandler::HistoryHandler(DOMUIHost* dom_ui_host)
     : dom_ui_host_(dom_ui_host) {
   dom_ui_host->RegisterMessageCallback("showHistoryPage",
       NewCallback(this, &HistoryHandler::HandleShowHistoryPage));
   dom_ui_host->RegisterMessageCallback("searchHistoryPage",
       NewCallback(this, &HistoryHandler::HandleSearchHistoryPage));
 }
@@ skipping 173 matching lines @@
 void NewTabUIContents::RequestOpenURL(const GURL& url,
                                       const GURL& /*referrer*/,
                                       WindowOpenDisposition disposition) {
   // The user opened a URL on the page (including "open in new window").
   // We count all such clicks as AUTO_BOOKMARK, which increments the site's
   // visit count (which is used for ranking the most visited entries).
   // Note this means we're including clicks on not only most visited thumbnails,
   // but also clicks on recently bookmarked.
   OpenURL(url, GURL(), disposition, PageTransition::AUTO_BOOKMARK);
 }