Introduce content::PageState (again).

components/sessions/serialized_navigation_entry.cc

 // Copyright 2013 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 "components/sessions/serialized_navigation_entry.h"
 
 #include "base/pickle.h"
 #include "base/utf_string_conversions.h"
 #include "content/public/browser/favicon_status.h"
 #include "content/public/browser/navigation_controller.h"
 #include "content/public/browser/navigation_entry.h"
 #include "sync/protocol/session_specifics.pb.h"
 #include "sync/util/time.h"
 #include "third_party/WebKit/Source/Platform/chromium/public/WebReferrerPolicy.h"
-#include "webkit/glue/glue_serialize.h"
 
 using content::NavigationEntry;
 
 namespace sessions {
 
 const char kSearchTermsKey[] = "search_terms";
 
 SerializedNavigationEntry::SerializedNavigationEntry()
     : index_(-1),
       unique_id_(0),
       transition_type_(content::PAGE_TRANSITION_TYPED),
       has_post_data_(false),
       post_id_(-1),
       is_overriding_user_agent_(false),
       blocked_state_(STATE_INVALID) {}
 
 SerializedNavigationEntry::~SerializedNavigationEntry() {}
 
 // static
 SerializedNavigationEntry SerializedNavigationEntry::FromNavigationEntry(
     int index,
     const NavigationEntry& entry) {
   SerializedNavigationEntry navigation;
   navigation.index_ = index;
   navigation.unique_id_ = entry.GetUniqueID();
   navigation.referrer_ = entry.GetReferrer();
   navigation.virtual_url_ = entry.GetVirtualURL();
   navigation.title_ = entry.GetTitle();
-  navigation.content_state_ = entry.GetContentState();
+  navigation.page_state_ = entry.GetPageState();
   navigation.transition_type_ = entry.GetTransitionType();
   navigation.has_post_data_ = entry.GetHasPostData();
   navigation.post_id_ = entry.GetPostID();
   navigation.original_request_url_ = entry.GetOriginalRequestURL();
   navigation.is_overriding_user_agent_ = entry.GetIsOverridingUserAgent();
   navigation.timestamp_ = entry.GetTimestamp();
   // If you want to navigate a named frame in Chrome, you will first need to
   // add support for persisting it. It is currently only used for layout tests.
   CHECK(entry.GetFrameToNavigate().empty());
   entry.GetExtraData(kSearchTermsKey, &navigation.search_terms_);
   if (entry.GetFavicon().valid)
     navigation.favicon_url_ = entry.GetFavicon().url;
 
   return navigation;
 }
 
 SerializedNavigationEntry SerializedNavigationEntry::FromSyncData(
     int index,
     const sync_pb::TabNavigation& sync_data) {
   SerializedNavigationEntry navigation;
   navigation.index_ = index;
   navigation.unique_id_ = sync_data.unique_id();
   navigation.referrer_ =
       content::Referrer(GURL(sync_data.referrer()),
                         WebKit::WebReferrerPolicyDefault);
   navigation.virtual_url_ = GURL(sync_data.virtual_url());
   navigation.title_ = UTF8ToUTF16(sync_data.title());
-  navigation.content_state_ = sync_data.state();
+  navigation.page_state_ =
+      content::PageState::CreateFromEncodedData(sync_data.state());
 
   uint32 transition = 0;
   if (sync_data.has_page_transition()) {
     switch (sync_data.page_transition()) {
       case sync_pb::SyncEnums_PageTransition_LINK:
         transition = content::PAGE_TRANSITION_LINK;
         break;
       case sync_pb::SyncEnums_PageTransition_TYPED:
         transition = content::PAGE_TRANSITION_TYPED;
         break;
@@ skipping 115 matching lines @@
   HAS_POST_DATA = 1
 };
 
 }  // namespace
 
 // Pickle order:
 //
 // index_
 // virtual_url_
 // title_
-// content_state_
+// page_state_
 // transition_type_
 //
 // Added on later:
 //
 // type_mask (has_post_data_)
 // referrer_
 // original_request_url_
 // is_overriding_user_agent_
 // timestamp_
 // search_terms_
 
 void SerializedNavigationEntry::WriteToPickle(int max_size,
                                               Pickle* pickle) const {
   pickle->WriteInt(index_);
 
   int bytes_written = 0;
 
   WriteStringToPickle(pickle, &bytes_written, max_size,
                       virtual_url_.spec());
 
   WriteString16ToPickle(pickle, &bytes_written, max_size, title_);
 
-  std::string content_state = content_state_;
-  if (has_post_data_) {
-    content_state =
-        webkit_glue::RemovePasswordDataFromHistoryState(content_state);
-  }
-  WriteStringToPickle(pickle, &bytes_written, max_size, content_state);
+  content::PageState page_state = page_state_;
+  if (has_post_data_)
+    page_state = page_state.RemovePasswordData();
+
+  WriteStringToPickle(pickle, &bytes_written, max_size,
+                      page_state.ToEncodedData());
 
   pickle->WriteInt(transition_type_);
 
   const int type_mask = has_post_data_ ? HAS_POST_DATA : 0;
   pickle->WriteInt(type_mask);
 
   WriteStringToPickle(
       pickle, &bytes_written, max_size,
       referrer_.url.is_valid() ? referrer_.url.spec() : std::string());
 
   pickle->WriteInt(referrer_.policy);
 
   // Save info required to override the user agent.
   WriteStringToPickle(
       pickle, &bytes_written, max_size,
       original_request_url_.is_valid() ?
       original_request_url_.spec() : std::string());
   pickle->WriteBool(is_overriding_user_agent_);
   pickle->WriteInt64(timestamp_.ToInternalValue());
 
   WriteString16ToPickle(pickle, &bytes_written, max_size, search_terms_);
 }
 
 bool SerializedNavigationEntry::ReadFromPickle(PickleIterator* iterator) {
   *this = SerializedNavigationEntry();
-  std::string virtual_url_spec;
+  std::string virtual_url_spec, page_state_data;
   int transition_type_int = 0;
   if (!iterator->ReadInt(&index_) ||
       !iterator->ReadString(&virtual_url_spec) ||
       !iterator->ReadString16(&title_) ||
-      !iterator->ReadString(&content_state_) ||
+      !iterator->ReadString(&page_state_data) ||
       !iterator->ReadInt(&transition_type_int))
     return false;
   virtual_url_ = GURL(virtual_url_spec);
+  page_state_ = content::PageState::CreateFromEncodedData(page_state_data);
   transition_type_ = static_cast<content::PageTransition>(transition_type_int);
 
   // type_mask did not always exist in the written stream. As such, we
   // don't fail if it can't be read.
   int type_mask = 0;
   bool has_type_mask = iterator->ReadInt(&type_mask);
 
   if (has_type_mask) {
     has_post_data_ = type_mask & HAS_POST_DATA;
     // the "referrer" property was added after type_mask to the written
@@ skipping 45 matching lines @@
           referrer_,
           // Use a transition type of reload so that we don't incorrectly
           // increase the typed count.
           content::PAGE_TRANSITION_RELOAD,
           false,
           // The extra headers are not sync'ed across sessions.
           std::string(),
           browser_context));
 
   entry->SetTitle(title_);
-  entry->SetContentState(content_state_);
+  entry->SetPageState(page_state_);
   entry->SetPageID(page_id);
   entry->SetHasPostData(has_post_data_);
   entry->SetPostID(post_id_);
   entry->SetOriginalRequestURL(original_request_url_);
   entry->SetIsOverridingUserAgent(is_overriding_user_agent_);
   entry->SetTimestamp(timestamp_);
   entry->SetExtraData(kSearchTermsKey, search_terms_);
 
   // These fields should have default values.
   DCHECK_EQ(STATE_INVALID, blocked_state_);
@@ skipping 118 matching lines @@
   for (std::vector<SerializedNavigationEntry>::const_iterator
        it = navigations.begin(); it != navigations.end(); ++it) {
     entries.push_back(
         it->ToNavigationEntry(page_id, browser_context).release());
     ++page_id;
   }
   return entries;
 }
 
 }  // namespace sessions