[Sync] Add HTTP status codes to NavigationEntry and TabNavigation

chrome/browser/sessions/session_types.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_types.h"
 
 #include "base/basictypes.h"
 #include "base/pickle.h"
 #include "base/stl_util.h"
 #include "base/string_util.h"
 #include "base/utf_string_conversions.h"
 #include "chrome/browser/sessions/session_command.h"
 #include "chrome/browser/ui/browser.h"
 #include "content/public/browser/navigation_controller.h"
 #include "content/public/browser/navigation_entry.h"
 #include "sync/util/time.h"
 #include "third_party/WebKit/Source/Platform/chromium/public/WebReferrerPolicy.h"
 #include "webkit/glue/webkit_glue.h"
 
 using content::NavigationEntry;
 
 // TabNavigation --------------------------------------------------------------
 
 TabNavigation::TabNavigation()
     : index_(-1),
       unique_id_(0),
       transition_type_(content::PAGE_TRANSITION_TYPED),
       has_post_data_(false),
       post_id_(-1),
-      is_overriding_user_agent_(false) {}
+      is_overriding_user_agent_(false),
+      http_status_code_(0) {}
 
 TabNavigation::~TabNavigation() {}
 
 // static
 TabNavigation TabNavigation::FromNavigationEntry(
     int index,
     const NavigationEntry& entry) {
   TabNavigation 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.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();
+  navigation.http_status_code_ = entry.GetHttpStatusCode();
   return navigation;
 }
 
 TabNavigation TabNavigation::FromSyncData(
     int index,
     const sync_pb::TabNavigation& sync_data) {
   TabNavigation navigation;
   navigation.index_ = index;
   navigation.unique_id_ = sync_data.unique_id();
   navigation.referrer_ =
@@ skipping 64 matching lines @@
       transition |= content::PAGE_TRANSITION_HOME_PAGE;
   if (sync_data.navigation_chain_start())
       transition |= content::PAGE_TRANSITION_CHAIN_START;
   if (sync_data.navigation_chain_end())
       transition |= content::PAGE_TRANSITION_CHAIN_END;
 
   navigation.transition_type_ =
       static_cast<content::PageTransition>(transition);
 
   navigation.timestamp_ = base::Time();
+  navigation.http_status_code_ = sync_data.http_status_code();
 
   return navigation;
 }
 
 namespace {
 
 // Helper used by TabNavigation::WriteToPickle(). It writes |str| to
 // |pickle|, if and only if |str| fits within (|max_bytes| -
 // |*bytes_written|).  |bytes_written| is incremented to reflect the
 // data written.
@@ skipping 49 matching lines @@
 // content_state_
 // transition_type_
 //
 // Added on later:
 //
 // type_mask (has_post_data_)
 // referrer_
 // original_request_url_
 // is_overriding_user_agent_
 // timestamp_
+// http_status_code_
 
 void TabNavigation::WriteToPickle(Pickle* pickle) const {
   pickle->WriteInt(index_);
 
   // We only allow navigations up to 63k (which should be completely
   // reasonable). On the off chance we get one that is too big, try to
   // keep the url.
 
   // Bound the string data (which is variable length) to
   // |max_state_size bytes| bytes.
@@ skipping 24 matching lines @@
 
   pickle->WriteInt(referrer_.policy);
 
   // Save info required to override the user agent.
   WriteStringToPickle(
       pickle, &bytes_written, max_state_size,
       original_request_url_.is_valid() ?
       original_request_url_.spec() : std::string());
   pickle->WriteBool(is_overriding_user_agent_);
   pickle->WriteInt64(timestamp_.ToInternalValue());
+  pickle->WriteInt(http_status_code_);
 }
 
 bool TabNavigation::ReadFromPickle(PickleIterator* iterator) {
   *this = TabNavigation();
   std::string virtual_url_spec;
   int transition_type_int = 0;
   if (!iterator->ReadInt(&index_) ||
       !iterator->ReadString(&virtual_url_spec) ||
       !iterator->ReadString16(&title_) ||
       !iterator->ReadString(&content_state_) ||
@@ skipping 33 matching lines @@
     // Default to not overriding the user agent if we don't have info.
     if (!iterator->ReadBool(&is_overriding_user_agent_))
       is_overriding_user_agent_ = false;
 
     int64 timestamp_internal_value = 0;
     if (iterator->ReadInt64(&timestamp_internal_value)) {
       timestamp_ = base::Time::FromInternalValue(timestamp_internal_value);
     } else {
       timestamp_ = base::Time();
     }
+
+    if (!iterator->ReadInt(&http_status_code_))
+      http_status_code_ = 0;
   }
 
   return true;
 }
 
 scoped_ptr<NavigationEntry> TabNavigation::ToNavigationEntry(
     int page_id,
     content::BrowserContext* browser_context) const {
   scoped_ptr<NavigationEntry> entry(
       content::NavigationController::CreateNavigationEntry(
           virtual_url_,
           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->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->SetHttpStatusCode(http_status_code_);
 
   return entry.Pass();
 }
 
 // TODO(zea): perhaps sync state (scroll position, form entries, etc.) as well?
 // See http://crbug.com/67068.
 sync_pb::TabNavigation TabNavigation::ToSyncData() const {
   sync_pb::TabNavigation sync_data;
   sync_data.set_virtual_url(virtual_url_.spec());
   // FIXME(zea): Support referrer policy?
@@ skipping 71 matching lines @@
       (transition_type_ & content::PAGE_TRANSITION_HOME_PAGE) != 0);
   sync_data.set_navigation_chain_start(
       (transition_type_ & content::PAGE_TRANSITION_CHAIN_START) != 0);
   sync_data.set_navigation_chain_end(
       (transition_type_ & content::PAGE_TRANSITION_CHAIN_END) != 0);
 
   sync_data.set_unique_id(unique_id_);
   // TODO(akalin): Don't lose resolution, i.e. define a new timestamp
   // field with microsecond resolution and use that.
   sync_data.set_timestamp(syncer::TimeToProtoTime(timestamp_));
+  sync_data.set_http_status_code(http_status_code_);
 
   return sync_data;
 }
 
 // static
 std::vector<NavigationEntry*>
 TabNavigation::CreateNavigationEntriesFromTabNavigations(
     const std::vector<TabNavigation>& navigations,
     content::BrowserContext* browser_context) {
   int page_id = 0;
@@ skipping 56 matching lines @@
 SessionWindow::SessionWindow()
     : selected_tab_index(-1),
       type(Browser::TYPE_TABBED),
       is_constrained(true),
       show_state(ui::SHOW_STATE_DEFAULT) {
 }
 
 SessionWindow::~SessionWindow() {
   STLDeleteElements(&tabs);
 }