Introduce content::PageState (again).

content/browser/web_contents/navigation_controller_impl.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 "content/browser/web_contents/navigation_controller_impl.h"
 
 #include "base/bind.h"
 #include "base/logging.h"
 #include "base/string_number_conversions.h"  // Temporary
 #include "base/string_util.h"
@@ skipping 22 matching lines @@
 #include "content/public/browser/storage_partition.h"
 #include "content/public/browser/user_metrics.h"
 #include "content/public/browser/web_contents_delegate.h"
 #include "content/public/common/content_client.h"
 #include "content/public/common/content_constants.h"
 #include "content/public/common/url_constants.h"
 #include "net/base/escape.h"
 #include "net/base/mime_util.h"
 #include "net/base/net_util.h"
 #include "skia/ext/platform_canvas.h"
-#include "webkit/glue/glue_serialize.h"
 
 namespace content {
 namespace {
 
 const int kInvalidateAll = 0xFFFFFFFF;
 
 // Invoked when entries have been pruned, or removed. For example, if the
 // current entries are [google, digg, yahoo], with the current entry google,
 // and the user types in cnet, then digg and yahoo are pruned.
 void NotifyPrunedEntries(NavigationControllerImpl* nav_controller,
                          bool from_front,
                          int count) {
   PrunedDetails details;
   details.from_front = from_front;
   details.count = count;
   NotificationService::current()->Notify(
       NOTIFICATION_NAV_LIST_PRUNED,
       Source<NavigationController>(nav_controller),
       Details<PrunedDetails>(&details));
 }
 
 // Ensure the given NavigationEntry has a valid state, so that WebKit does not
 // get confused if we navigate back to it.
 //
 // An empty state is treated as a new navigation by WebKit, which would mean
 // losing the navigation entries and generating a new navigation entry after
 // this one. We don't want that. To avoid this we create a valid state which
 // WebKit will not treat as a new navigation.
-void SetContentStateIfEmpty(NavigationEntryImpl* entry) {
-  if (entry->GetContentState().empty()) {
-    entry->SetContentState(
-        webkit_glue::CreateHistoryStateForURL(entry->GetURL()));
-  }
+void SetPageStateIfEmpty(NavigationEntryImpl* entry) {
+  if (!entry->GetPageState().IsValid())
+    entry->SetPageState(PageState::CreateFromURL(entry->GetURL()));
 }
 
 NavigationEntryImpl::RestoreType ControllerRestoreTypeToEntryType(
     NavigationController::RestoreType type) {
   switch (type) {
     case NavigationController::RESTORE_CURRENT_SESSION:
       return NavigationEntryImpl::RESTORE_CURRENT_SESSION;
     case NavigationController::RESTORE_LAST_SESSION_EXITED_CLEANLY:
       return NavigationEntryImpl::RESTORE_LAST_SESSION_EXITED_CLEANLY;
     case NavigationController::RESTORE_LAST_SESSION_CRASHED:
       return NavigationEntryImpl::RESTORE_LAST_SESSION_CRASHED;
   }
   NOTREACHED();
   return NavigationEntryImpl::RESTORE_CURRENT_SESSION;
 }
 
 // Configure all the NavigationEntries in entries for restore. This resets
 // the transition type to reload and makes sure the content state isn't empty.
 void ConfigureEntriesForRestore(
     std::vector<linked_ptr<NavigationEntryImpl> >* entries,
     NavigationController::RestoreType type) {
   for (size_t i = 0; i < entries->size(); ++i) {
     // Use a transition type of reload so that we don't incorrectly increase
     // the typed count.
     (*entries)[i]->SetTransitionType(PAGE_TRANSITION_RELOAD);
     (*entries)[i]->set_restore_type(ControllerRestoreTypeToEntryType(type));
     // NOTE(darin): This code is only needed for backwards compat.
-    SetContentStateIfEmpty((*entries)[i].get());
+    SetPageStateIfEmpty((*entries)[i].get());
   }
 }
 
 // See NavigationController::IsURLInPageNavigation for how this works and why.
 bool AreURLsInPageNavigation(const GURL& existing_url,
                              const GURL& new_url,
                              bool renderer_says_in_page) {
   if (existing_url == new_url)
     return renderer_says_in_page;
 
@@ skipping 647 matching lines @@
       time_smoother_.GetSmoothedTime(get_timestamp_callback_.Run());
   DVLOG(1) << "Navigation finished at (smoothed) timestamp "
            << timestamp.ToInternalValue();
 
   // We should not have a pending entry anymore.  Clear it again in case any
   // error cases above forgot to do so.
   DiscardNonCommittedEntriesInternal();
 
   // All committed entries should have nonempty content state so WebKit doesn't
   // get confused when we go back to them (see the function for details).
-  DCHECK(!params.content_state.empty());
+  DCHECK(params.page_state.IsValid());
   NavigationEntryImpl* active_entry =
       NavigationEntryImpl::FromNavigationEntry(GetLastCommittedEntry());
   active_entry->SetTimestamp(timestamp);
-  active_entry->SetContentState(params.content_state);
+  active_entry->SetPageState(params.page_state);
   // No longer needed since content state will hold the post data if any.
   active_entry->SetBrowserInitiatedPostData(NULL);
 
   // Once committed, we do not need to track if the entry was initiated by
   // the renderer.
   active_entry->set_is_renderer_initiated(false);
 
   // Once committed, we no longer need to track whether the session history was
   // cleared. Navigating to this entry again shouldn't clear it again.
   active_entry->set_should_clear_history_list(false);
@@ skipping 890 matching lines @@
     }
   }
 }
 
 void NavigationControllerImpl::SetGetTimestampCallbackForTest(
     const base::Callback<base::Time()>& get_timestamp_callback) {
   get_timestamp_callback_ = get_timestamp_callback;
 }
 
 }  // namespace content