Plumb shift-reload down into newly-added shift-reload API.

chrome/browser/tab_contents/navigation_controller.cc

 // Copyright (c) 2009 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/tab_contents/navigation_controller.h"
 
 #include "app/resource_bundle.h"
 #include "base/file_util.h"
 #include "base/logging.h"
 #include "base/string_util.h"
@@ skipping 155 matching lines @@
 
   // Populate entries_ from the supplied TabNavigations.
   needs_reload_ = true;
   CreateNavigationEntriesFromTabNavigations(navigations, &entries_);
 
   // And finish the restore.
   FinishRestore(selected_navigation, from_last_session);
 }
 
 void NavigationController::Reload(bool check_for_repost) {
+  ReloadInternal(check_for_repost, RELOAD_VALIDATING_CACHE);
+}
+void NavigationController::ReloadIgnoringCache(bool check_for_repost) {
+  ReloadInternal(check_for_repost, RELOAD_IGNORING_CACHE);
+}
+
+void NavigationController::ReloadInternal(bool check_for_repost,
+                                          ReloadType reload_type) {
   // Reloading a transient entry does nothing.
   if (transient_entry_index_ != -1)
     return;
 
   DiscardNonCommittedEntriesInternal();
   int current_index = GetCurrentEntryIndex();
   if (check_for_repost_ && check_for_repost && current_index != -1 &&
       GetEntryAtIndex(current_index)->has_post_data()) {
     // The user is asking to reload a page with POST data. Prompt to make sure
     // they really want to do this. If they do, the dialog will call us back
     // with check_for_repost = false.
     tab_contents_->Activate();
     tab_contents_->delegate()->ShowRepostFormWarningDialog(tab_contents_);
   } else {
     // Base the navigation on where we are now...
     int current_index = GetCurrentEntryIndex();
 
     // If we are no where, then we can't reload.  TODO(darin): We should add a
     // CanReload method.
     if (current_index == -1)
       return;
 
     DiscardNonCommittedEntriesInternal();
 
     pending_entry_index_ = current_index;
     entries_[pending_entry_index_]->set_transition_type(PageTransition::RELOAD);
-    NavigateToPendingEntry(true);
+    NavigateToPendingEntry(reload_type);
   }
 }
 
 NavigationEntry* NavigationController::GetEntryWithPageID(
     SiteInstance* instance, int32 page_id) const {
   int index = GetEntryIndexWithPageID(instance, page_id);
   return (index != -1) ? entries_[index].get() : NULL;
 }
 
 void NavigationController::LoadEntry(NavigationEntry* entry) {
   // Handle non-navigational URLs that popup dialogs and such, these should not
   // actually navigate.
   if (HandleNonNavigationAboutURL(entry->url()))
     return;
 
   // When navigating to a new page, we don't know for sure if we will actually
   // end up leaving the current page.  The new page load could for example
   // result in a download or a 'no content' response (e.g., a mailto: URL).
   DiscardNonCommittedEntriesInternal();
   pending_entry_ = entry;
   NotificationService::current()->Notify(
       NotificationType::NAV_ENTRY_PENDING,
       Source<NavigationController>(this),
       NotificationService::NoDetails());
-  NavigateToPendingEntry(false);
+  NavigateToPendingEntry(NO_RELOAD);
 }
 
 NavigationEntry* NavigationController::GetActiveEntry() const {
   if (transient_entry_index_ != -1)
     return entries_[transient_entry_index_].get();
   if (pending_entry_)
     return pending_entry_;
   return GetLastCommittedEntry();
 }
 
@@ skipping 43 matching lines @@
     NOTREACHED();
     return;
   }
 
   // Base the navigation on where we are now...
   int current_index = GetCurrentEntryIndex();
 
   DiscardNonCommittedEntries();
 
   pending_entry_index_ = current_index - 1;
-  NavigateToPendingEntry(false);
+  NavigateToPendingEntry(NO_RELOAD);
 }
 
 void NavigationController::GoForward() {
   if (!CanGoForward()) {
     NOTREACHED();
     return;
   }
 
   bool transient = (transient_entry_index_ != -1);
 
   // Base the navigation on where we are now...
   int current_index = GetCurrentEntryIndex();
 
   DiscardNonCommittedEntries();
 
   pending_entry_index_ = current_index;
   // If there was a transient entry, we removed it making the current index
   // the next page.
   if (!transient)
     pending_entry_index_++;
 
-  NavigateToPendingEntry(false);
+  NavigateToPendingEntry(NO_RELOAD);
 }
 
 void NavigationController::GoToIndex(int index) {
   if (index < 0 || index >= static_cast<int>(entries_.size())) {
     NOTREACHED();
     return;
   }
 
   if (transient_entry_index_ != -1) {
     if (index == transient_entry_index_) {
       // Nothing to do when navigating to the transient.
       return;
     }
     if (index > transient_entry_index_) {
       // Removing the transient is goint to shift all entries by 1.
       index--;
     }
   }
 
   DiscardNonCommittedEntries();
 
   pending_entry_index_ = index;
-  NavigateToPendingEntry(false);
+  NavigateToPendingEntry(NO_RELOAD);
 }
 
 void NavigationController::GoToOffset(int offset) {
   int index = (transient_entry_index_ != -1) ?
                   transient_entry_index_ + offset :
                   last_committed_entry_index_ + offset;
   if (index < 0 || index >= entry_count())
     return;
 
   GoToIndex(index);
 }
 
 void NavigationController::RemoveEntryAtIndex(int index,
                                               const GURL& default_url) {
   int size = static_cast<int>(entries_.size());
   DCHECK(index < size);
 
   DiscardNonCommittedEntries();
 
   entries_.erase(entries_.begin() + index);
 
   if (last_committed_entry_index_ == index) {
     last_committed_entry_index_--;
     // We removed the currently shown entry, so we have to load something else.
     if (last_committed_entry_index_ != -1) {
       pending_entry_index_ = last_committed_entry_index_;
-      NavigateToPendingEntry(false);
+      NavigateToPendingEntry(NO_RELOAD);
     } else {
       // If there is nothing to show, show a default page.
       LoadURL(default_url.is_empty() ? GURL("about:blank") : default_url,
               GURL(), PageTransition::START_PAGE);
     }
   } else if (last_committed_entry_index_ > index) {
     last_committed_entry_index_--;
   }
 }
 
@@ skipping 559 matching lines @@
   tab_contents_->UpdateMaxPageID(entry->page_id());
 }
 
 void NavigationController::SetWindowID(const SessionID& id) {
   window_id_ = id;
   NotificationService::current()->Notify(NotificationType::TAB_PARENTED,
                                          Source<NavigationController>(this),
                                          NotificationService::NoDetails());
 }
 
-void NavigationController::NavigateToPendingEntry(bool reload) {
+void NavigationController::NavigateToPendingEntry(ReloadType reload_type) {
   needs_reload_ = false;
 
   // For session history navigations only the pending_entry_index_ is set.
   if (!pending_entry_) {
     DCHECK(pending_entry_index_ != -1);
     pending_entry_ = entries_[pending_entry_index_].get();
   }
 
-  if (!tab_contents_->NavigateToPendingEntry(reload))
+  if (!tab_contents_->NavigateToPendingEntry(reload_type))
     DiscardNonCommittedEntries();
 }
 
 void NavigationController::NotifyNavigationEntryCommitted(
     LoadCommittedDetails* details,
     int extra_invalidate_flags) {
   details->entry = GetActiveEntry();
   NotificationDetails notification_details =
       Details<LoadCommittedDetails>(details);
 
@@ skipping 25 matching lines @@
 }
 
 void NavigationController::LoadIfNecessary() {
   if (!needs_reload_)
     return;
 
   // Calling Reload() results in ignoring state, and not loading.
   // Explicitly use NavigateToPendingEntry so that the renderer uses the
   // cached state.
   pending_entry_index_ = last_committed_entry_index_;
-  NavigateToPendingEntry(false);
+  NavigateToPendingEntry(NO_RELOAD);
 }
 
 void NavigationController::NotifyEntryChanged(const NavigationEntry* entry,
                                               int index) {
   EntryChangedDetails det;
   det.changed_entry = entry;
   det.index = index;
   NotificationService::current()->Notify(NotificationType::NAV_ENTRY_CHANGED,
                                          Source<NavigationController>(this),
                                          Details<EntryChangedDetails>(&det));
@@ skipping 35 matching lines @@
       return i;
   }
   return -1;
 }
 
 NavigationEntry* NavigationController::GetTransientEntry() const {
   if (transient_entry_index_ == -1)
     return NULL;
   return entries_[transient_entry_index_].get();
 }