Miscellaneous cleanups from several months ago I never got around to landing.

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 472 matching lines @@
 }
 
 void SessionService::SetTabUserAgentOverride(
     const SessionID& window_id,
     const SessionID& tab_id,
     const std::string& user_agent_override) {
   if (!ShouldTrackChangesToWindow(window_id))
     return;
 
   ScheduleCommand(CreateSetTabUserAgentOverrideCommand(
-                      kCommandSetTabUserAgentOverride,
-                      tab_id.id(),
-                      user_agent_override));
+      kCommandSetTabUserAgentOverride, tab_id.id(), user_agent_override));
 }
 
 SessionService::Handle SessionService::GetLastSession(
     CancelableRequestConsumerBase* consumer,
     const SessionCallback& callback) {
   return ScheduleGetLastSessionCommands(
       new InternalSessionRequest(
           base::Bind(&SessionService::OnGotSessionCommands,
                      base::Unretained(this)),
           callback),
       consumer);
 }
 
 void SessionService::Save() {
   bool had_commands = !pending_commands().empty();
   BaseSessionService::Save();
   if (had_commands) {
-    RecordSessionUpdateHistogramData(
-        chrome::NOTIFICATION_SESSION_SERVICE_SAVED,
-        &last_updated_save_time_);
+    RecordSessionUpdateHistogramData(chrome::NOTIFICATION_SESSION_SERVICE_SAVED,
+                                     &last_updated_save_time_);
     content::NotificationService::current()->Notify(
         chrome::NOTIFICATION_SESSION_SERVICE_SAVED,
         content::Source<Profile>(profile()),
         content::NotificationService::NoDetails());
   }
 }
 
 void SessionService::Init() {
   // Register for the notifications we're interested in.
   registrar_.Add(this, chrome::NOTIFICATION_TAB_PARENTED,
@@ skipping 77 matching lines @@
       break;
     }
 
     case chrome::NOTIFICATION_TAB_PARENTED: {
       TabContents* tab = content::Source<TabContents>(source).ptr();
       if (tab->profile() != profile())
         return;
       SetTabWindow(tab->restore_tab_helper()->window_id(),
                    tab->restore_tab_helper()->session_id());
       if (tab->extension_tab_helper()->extension_app()) {
-        SetTabExtensionAppID(
-            tab->restore_tab_helper()->window_id(),
+        SetTabExtensionAppID(tab->restore_tab_helper()->window_id(),
             tab->restore_tab_helper()->session_id(),
             tab->extension_tab_helper()->extension_app()->id());
       }
 
       // Record the association between the SessionStorageNamespace and the
       // tab.
       //
       // TODO(ajwong): This should be processing the whole map rather than
       // just the default. This in particular will not work for tabs with only
       // isolated apps which won't have a default partition.
@@ skipping 25 matching lines @@
     }
 
     case content::NOTIFICATION_NAV_LIST_PRUNED: {
       TabContents* tab = TabContents::FromWebContents(
           content::Source<content::NavigationController>(source).ptr()->
               GetWebContents());
       if (!tab || tab->profile() != profile())
         return;
       content::Details<content::PrunedDetails> pruned_details(details);
       if (pruned_details->from_front) {
-        TabNavigationPathPrunedFromFront(
-            tab->restore_tab_helper()->window_id(),
+        TabNavigationPathPrunedFromFront(tab->restore_tab_helper()->window_id(),
             tab->restore_tab_helper()->session_id(),
             pruned_details->count);
       } else {
-        TabNavigationPathPrunedFromBack(
-            tab->restore_tab_helper()->window_id(),
+        TabNavigationPathPrunedFromBack(tab->restore_tab_helper()->window_id(),
             tab->restore_tab_helper()->session_id(),
             tab->web_contents()->GetController().GetEntryCount());
       }
-      RecordSessionUpdateHistogramData(content::NOTIFICATION_NAV_LIST_PRUNED,
-          &last_updated_nav_list_pruned_time_);
+      RecordSessionUpdateHistogramData(type,
+                                       &last_updated_nav_list_pruned_time_);
       break;
     }
 
     case content::NOTIFICATION_NAV_ENTRY_CHANGED: {
       TabContents* tab = TabContents::FromWebContents(
           content::Source<content::NavigationController>(source).ptr()->
               GetWebContents());
       if (!tab || tab->profile() != profile())
         return;
       content::Details<content::EntryChangedDetails> changed(details);
-      UpdateTabNavigation(
-          tab->restore_tab_helper()->window_id(),
-          tab->restore_tab_helper()->session_id(),
-          changed->index, *changed->changed_entry);
+      UpdateTabNavigation(tab->restore_tab_helper()->window_id(),
+                          tab->restore_tab_helper()->session_id(),
+                          changed->index, *changed->changed_entry);
       break;
     }
 
     case content::NOTIFICATION_NAV_ENTRY_COMMITTED: {
       TabContents* tab = TabContents::FromWebContents(
           content::Source<content::NavigationController>(source).ptr()->
               GetWebContents());
       if (!tab || tab->profile() != profile())
         return;
       int current_entry_index =
           tab->web_contents()->GetController().GetCurrentEntryIndex();
       SetSelectedNavigationIndex(tab->restore_tab_helper()->window_id(),
-                                 tab->restore_tab_helper()->session_id(),
-                                 current_entry_index);
-      UpdateTabNavigation(
-          tab->restore_tab_helper()->window_id(),
+          tab->restore_tab_helper()->session_id(), current_entry_index);
+      UpdateTabNavigation(tab->restore_tab_helper()->window_id(),
           tab->restore_tab_helper()->session_id(),
           current_entry_index,
           *tab->web_contents()->GetController().GetEntryAtIndex(
               current_entry_index));
       content::Details<content::LoadCommittedDetails> changed(details);
       if (changed->type == content::NAVIGATION_TYPE_NEW_PAGE ||
         changed->type == content::NAVIGATION_TYPE_EXISTING_PAGE) {
-        RecordSessionUpdateHistogramData(
-            content::NOTIFICATION_NAV_ENTRY_COMMITTED,
-            &last_updated_nav_entry_commit_time_);
+        RecordSessionUpdateHistogramData(type,
+                                         &last_updated_nav_entry_commit_time_);
       }
       break;
     }
 
     case chrome::NOTIFICATION_TAB_CONTENTS_APPLICATION_EXTENSION_CHANGED: {
       extensions::TabHelper* extension_tab_helper =
           content::Source<extensions::TabHelper>(source).ptr();
       if (extension_tab_helper->tab_contents()->profile() != profile())
         return;
       if (extension_tab_helper->extension_app()) {
         RestoreTabHelper* helper =
             extension_tab_helper->tab_contents()->restore_tab_helper();
-        SetTabExtensionAppID(helper->window_id(),
-                             helper->session_id(),
+        SetTabExtensionAppID(helper->window_id(), helper->session_id(),
                              extension_tab_helper->extension_app()->id());
       }
       break;
     }
 
     default:
       NOTREACHED();
   }
 }
 
 void SessionService::SetTabExtensionAppID(
     const SessionID& window_id,
     const SessionID& tab_id,
     const std::string& extension_app_id) {
   if (!ShouldTrackChangesToWindow(window_id))
     return;
 
-  ScheduleCommand(CreateSetTabExtensionAppIDCommand(
-                      kCommandSetExtensionAppID,
-                      tab_id.id(),
-                      extension_app_id));
+  ScheduleCommand(CreateSetTabExtensionAppIDCommand(kCommandSetExtensionAppID,
+      tab_id.id(), extension_app_id));
 }
 
 SessionCommand* SessionService::CreateSetSelectedTabInWindow(
     const SessionID& window_id,
     int index) {
   SelectedTabInIndexPayload payload = { 0 };
   payload.id = window_id.id();
   payload.index = index;
   SessionCommand* command = new SessionCommand(kCommandSetSelectedTabInIndex,
                                  sizeof(payload));
@@ skipping 974 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);
   }
 }