Add the navigation redirect-chain to Sync sessions proto for offline analysis.

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/strings/utf_string_conversions.h"
 #include "content/public/browser/favicon_status.h"
 #include "content/public/browser/navigation_controller.h"
@@ skipping 37 matching lines @@
   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;
   navigation.http_status_code_ = entry.GetHttpStatusCode();
+  navigation.redirect_chain_ = entry.GetRedirectChain();
 
   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();
@@ skipping 72 matching lines @@
   navigation.transition_type_ =
       static_cast<content::PageTransition>(transition);
 
   navigation.timestamp_ = base::Time();
   navigation.search_terms_ = base::UTF8ToUTF16(sync_data.search_terms());
   if (sync_data.has_favicon_url())
     navigation.favicon_url_ = GURL(sync_data.favicon_url());
 
   navigation.http_status_code_ = sync_data.http_status_code();
 
+  // The redirect chain does not need to be synced down.

[haitaol1, 2014/01/17 23:52:23]

I think the comment should be on redirect_chain_ saying it's only filled for
local session.

[Donn Denman, 2014/01/18 01:30:19]

Done.

+
   // We shouldn't sync session data for managed users down at the moment.
   DCHECK(!sync_data.has_blocked_state());
   DCHECK_EQ(0, sync_data.content_pack_categories_size());
 
   return navigation;
 }
 
 namespace {
 
 // Helper used by SerializedNavigationEntry::WriteToPickle(). It writes |str| to
@@ skipping 54 matching lines @@
 //
 // Added on later:
 //
 // type_mask (has_post_data_)
 // referrer_
 // original_request_url_
 // is_overriding_user_agent_
 // timestamp_
 // search_terms_
 // http_status_code_
+// redirect_chain_
 
 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());
 
@@ skipping 21 matching lines @@
   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_);
 
   pickle->WriteInt(http_status_code_);
+
+  // Redirect chain has variable number of entries.
+  pickle->WriteUInt16(redirect_chain_.size());
+  for (size_t i = 0; i < redirect_chain_.size(); i++) {
+    GURL redirect_url = redirect_chain_.at(i);
+    WriteStringToPickle(pickle, &bytes_written, max_size,
+        redirect_url.is_valid() ? redirect_url.spec() : std::string());
+  }
 }
 
 bool SerializedNavigationEntry::ReadFromPickle(PickleIterator* iterator) {
   *this = SerializedNavigationEntry();
   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(&page_state_data) ||
@@ skipping 41 matching lines @@
     } else {
       timestamp_ = base::Time();
     }
 
     // If the search terms field can't be found, leave it empty.
     if (!iterator->ReadString16(&search_terms_))
       search_terms_.clear();
 
     if (!iterator->ReadInt(&http_status_code_))
       http_status_code_ = 0;
+
+    // The redirect chain is only in newer pickle streams.
+    unsigned short redirect_chain_length = 0;
+    if (iterator->ReadUInt16(&redirect_chain_length)) {
+      std::vector<GURL> full_redirect_chain;
+      bool was_full_chain_read_successfully = true;
+      for (size_t i = 0; i < redirect_chain_length; i++) {
+        std::string a_redirect;
+        if (iterator->ReadString(&a_redirect)) {
+          full_redirect_chain.push_back(GURL(a_redirect));
+        } else {
+          was_full_chain_read_successfully = false;
+        }
+      }
+      if (was_full_chain_read_successfully) {
+        redirect_chain_ = full_redirect_chain;
+      }
+    }
   }
 
   return true;
 }
 
 scoped_ptr<NavigationEntry> SerializedNavigationEntry::ToNavigationEntry(
     int page_id,
     content::BrowserContext* browser_context) const {
   scoped_ptr<NavigationEntry> entry(
       content::NavigationController::CreateNavigationEntry(
@@ skipping 10 matching lines @@
   entry->SetTitle(title_);
   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_);
   entry->SetHttpStatusCode(http_status_code_);
+  entry->SetRedirectChain(redirect_chain_);
 
   // These fields should have default values.
   DCHECK_EQ(STATE_INVALID, blocked_state_);
   DCHECK_EQ(0u, content_pack_categories_.size());
 
   return entry.Pass();
 }
 
 // TODO(zea): perhaps sync state (scroll position, form entries, etc.) as well?
 // See http://crbug.com/67068.
@@ skipping 94 matching lines @@
     sync_data.set_blocked_state(
         static_cast<sync_pb::TabNavigation_BlockedState>(blocked_state_));
   }
 
   for (std::set<std::string>::const_iterator it =
            content_pack_categories_.begin();
        it != content_pack_categories_.end(); ++it) {
     sync_data.add_content_pack_categories(*it);
   }
 
+  // Copy all redirect chain entries except the last URL.
+  for (size_t i = 0; i < redirect_chain_.size(); i++) {
+    bool is_last_url = (i == redirect_chain_.size() - 1);
+    if (is_last_url) {
+      bool did_redirect = redirect_chain_.size() > 1;
+      if (did_redirect &&
+          sync_data.virtual_url() != redirect_chain_.at(i).spec()) {
+        sync_data.set_last_navigation_redirect_url(
+            redirect_chain_.at(i).spec());
+      }
+    } else {
+      sync_pb::NavigationRedirect *navigation_redirect =
+          sync_data.add_navigation_redirect();
+      navigation_redirect->set_url(redirect_chain_.at(i).spec());
+    }
+  }
   return sync_data;
 }
 
 // static
 std::vector<NavigationEntry*> SerializedNavigationEntry::ToNavigationEntries(
     const std::vector<SerializedNavigationEntry>& navigations,
     content::BrowserContext* browser_context) {
   int page_id = 0;
   std::vector<NavigationEntry*> entries;
   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