[Android] Upstream remaining changes to NTP UI code.

chrome/browser/ui/webui/ntp/recently_closed_tabs_handler.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/webui/ntp/recently_closed_tabs_handler.h"
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/metrics/histogram.h"
 #include "chrome/browser/profiles/profile.h"
@@ skipping 39 matching lines @@
 
 }  // namespace
 
 void RecentlyClosedTabsHandler::RegisterMessages() {
   web_ui()->RegisterMessageCallback("getRecentlyClosedTabs",
       base::Bind(&RecentlyClosedTabsHandler::HandleGetRecentlyClosedTabs,
                  base::Unretained(this)));
   web_ui()->RegisterMessageCallback("reopenTab",
       base::Bind(&RecentlyClosedTabsHandler::HandleReopenTab,
                  base::Unretained(this)));
+  web_ui()->RegisterMessageCallback("clearRecentlyClosed",
+      base::Bind(&RecentlyClosedTabsHandler::HandleClearRecentlyClosed,
+                 base::Unretained(this)));
 }
 
 RecentlyClosedTabsHandler::~RecentlyClosedTabsHandler() {
   if (tab_restore_service_)
     tab_restore_service_->RemoveObserver(this);
 }
 
 void RecentlyClosedTabsHandler::HandleReopenTab(const ListValue* args) {
   if (!tab_restore_service_)
     return;
 
-  double index = -1.0;
-  CHECK(args->GetDouble(1, &index));
-
-  // There are actually less than 20 restore tab items displayed in the UI.
-  UMA_HISTOGRAM_ENUMERATION("NewTabPage.SessionRestore",
-                            static_cast<int>(index), 20);
-
   double session_to_restore = 0.0;
   CHECK(args->GetDouble(0, &session_to_restore));
 
 #if defined(OS_ANDROID)
   // Find and remove the corresponding tab entry from TabRestoreService.
   // We take ownership of the returned tab.
   scoped_ptr<TabRestoreService::Tab> tab_entry(
       tab_restore_service_->RemoveTabEntryById(static_cast<int>(
           session_to_restore)));
   if (tab_entry.get() == NULL)
     return;
 
   // RestoreForeignSessionTab needs a SessionTab.
   SessionTab session_tab;
   session_tab.current_navigation_index = tab_entry->current_navigation_index;
   session_tab.navigations = tab_entry->navigations;
 
   SessionRestore::RestoreForeignSessionTab(web_ui()->GetWebContents(),
                                            session_tab, NEW_FOREGROUND_TAB);
 #else
+  double index = -1.0;
+  CHECK(args->GetDouble(1, &index));
+
+  // There are actually less than 20 restore tab items displayed in the UI.
+  UMA_HISTOGRAM_ENUMERATION("NewTabPage.SessionRestore",
+                            static_cast<int>(index), 20);
+
   TabRestoreServiceDelegate* delegate =
       TabRestoreServiceDelegate::FindDelegateForWebContents(
           web_ui()->GetWebContents());
   if (!delegate)
     return;
   WindowOpenDisposition disposition =
       web_ui_util::GetDispositionFromClick(args, 2);
   tab_restore_service_->RestoreEntryById(delegate,
                                          static_cast<int>(session_to_restore),
                                          disposition);
   // The current tab has been nuked at this point; don't touch any member
   // variables.
 #endif
 }
 
+void RecentlyClosedTabsHandler::HandleClearRecentlyClosed(
+    const ListValue* args) {
+  if (tab_restore_service_)

[newt (away), 2012/10/02 13:07:31]

Not totally sure about this.  If tab_restore_service_ is null, then perhaps we
still want to clear the recently closed entries.  But currently, this is
triggered only when the user long presses on a recently closed entry and selects
"remove", at which point tab_restore_service_ already exists.

I could do something like in HandleGetRecentlyClosedTabs to make this work when
tab_restore_service_ is null.  Thoughts?

[Evan Stade, 2012/10/02 14:42:43]

pull out an EnsureTabRestoreService function that inits (or attempts to)
tab_restore_service_

[newt (away), 2012/10/05 13:31:05]

Done.

+    tab_restore_service_->ClearEntries();
+}
+
 void RecentlyClosedTabsHandler::HandleGetRecentlyClosedTabs(
     const ListValue* args) {
   if (!tab_restore_service_) {
     tab_restore_service_ =
         TabRestoreServiceFactory::GetForProfile(Profile::FromWebUI(web_ui()));
 
     // TabRestoreServiceFactory::GetForProfile() can return NULL (i.e., when in
     // Off the Record mode)
     if (tab_restore_service_) {
       // This does nothing if the tabs have already been loaded or they
@@ skipping 41 matching lines @@
       DCHECK_EQ(entry->type, TabRestoreService::WINDOW);
       WindowToValue(*static_cast<TabRestoreService::Window*>(entry),
                     entry_dict.get());
     }
 
     entry_dict->SetInteger("sessionId", entry->id);
     entry_list_value->Append(entry_dict.release());
     added_count++;
   }
 }