Move referrer policy to a different field when serializing.

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 "components/sessions/core/serialized_navigation_driver.h"
 #include "sync/protocol/session_specifics.pb.h"
@@ skipping 18 matching lines @@
 }
 
 SerializedNavigationEntry::~SerializedNavigationEntry() {}
 
 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_url_ = GURL(sync_data.referrer());
-  navigation.referrer_policy_ = sync_data.referrer_policy();
+  if (sync_data.has_correct_referrer_policy()) {
+    navigation.referrer_url_ = GURL(sync_data.referrer());
+    navigation.referrer_policy_ = sync_data.correct_referrer_policy();
+  } else {
+    int mapped_referrer_policy;
+    if (SerializedNavigationDriver::Get()->MapReferrerPolicyToNewValues(
+            sync_data.referrer_policy(), &mapped_referrer_policy)) {
+      navigation.referrer_url_ = GURL(sync_data.referrer());
+    } else {
+      navigation.referrer_url_ = GURL();
+    }
+    navigation.referrer_policy_ = mapped_referrer_policy;
+  }
   navigation.virtual_url_ = GURL(sync_data.virtual_url());
   navigation.title_ = base::UTF8ToUTF16(sync_data.title());
   navigation.encoded_page_state_ = sync_data.state();
 
   uint32 transition = 0;
   if (sync_data.has_page_transition()) {
     switch (sync_data.page_transition()) {
       case sync_pb::SyncEnums_PageTransition_LINK:
         transition = ui::PAGE_TRANSITION_LINK;
         break;
@@ skipping 125 matching lines @@
 // index_
 // virtual_url_
 // title_
 // encoded_page_state_
 // transition_type_
 //
 // Added on later:
 //
 // type_mask (has_post_data_)
 // referrer_url_
-// referrer_policy_
+// referrer_policy_ (broken, crbug.com/450589)
 // original_request_url_
 // is_overriding_user_agent_
 // timestamp_
 // search_terms_
 // http_status_code_
+// referrer_policy_
 
 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_);
 
   const std::string encoded_page_state =
       SerializedNavigationDriver::Get()->GetSanitizedPageStateForPickle(this);
   WriteStringToPickle(pickle, &bytes_written, max_size, encoded_page_state);
 
   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_);
+  int mapped_referrer_policy;
+  if (SerializedNavigationDriver::Get()->MapReferrerPolicyToOldValues(
+          referrer_policy_, &mapped_referrer_policy)) {
+    WriteStringToPickle(
+        pickle, &bytes_written, max_size,
+        referrer_url_.is_valid() ? referrer_url_.spec() : std::string());
+  } else {
+    WriteStringToPickle(pickle, &bytes_written, max_size, std::string());
+  }
+  pickle->WriteInt(mapped_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_);
 
   pickle->WriteInt(http_status_code_);
+
+  pickle->WriteInt(referrer_policy_);
 }
 
 bool SerializedNavigationEntry::ReadFromPickle(PickleIterator* iterator) {
   *this = SerializedNavigationEntry();
   std::string virtual_url_spec;
   int transition_type_int = 0;
   if (!iterator->ReadInt(&index_) ||
       !iterator->ReadString(&virtual_url_spec) ||
       !iterator->ReadString16(&title_) ||
       !iterator->ReadString(&encoded_page_state_) ||
@@ skipping 11 matching lines @@
     has_post_data_ = type_mask & HAS_POST_DATA;
     // the "referrer" property was added after type_mask to the written
     // stream. As such, we don't fail if it can't be read.
     std::string referrer_spec;
     if (!iterator->ReadString(&referrer_spec))
       referrer_spec = std::string();
     referrer_url_ = GURL(referrer_spec);
 
     // The "referrer policy" property was added even later, so we fall back to
     // the default policy if the property is not present.
-    if (!iterator->ReadInt(&referrer_policy_))
+    //
+    // Note: due to crbug.com/450589 this value might be incorrect, and a
+    // corrected version is stored later in the pickle.
+    if (!iterator->ReadInt(&referrer_policy_)) {
       referrer_policy_ =
           SerializedNavigationDriver::Get()->GetDefaultReferrerPolicy();
+    } else {
+      int mapped_referrer_policy;
+      if (!SerializedNavigationDriver::Get()->MapReferrerPolicyToNewValues(
+              referrer_policy_, &mapped_referrer_policy)) {
+        referrer_url_ = GURL();
+      }
+      referrer_policy_ = mapped_referrer_policy;
+    }
 
     // If the original URL can't be found, leave it empty.
     std::string original_request_url_spec;
     if (!iterator->ReadString(&original_request_url_spec))
       original_request_url_spec = std::string();
     original_request_url_ = GURL(original_request_url_spec);
 
     // 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 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;
+
+    // Correct referrer policy (if present).
+    int correct_referrer_policy;
+    if (iterator->ReadInt(&correct_referrer_policy))
+      referrer_policy_ = correct_referrer_policy;
   }
 
   SerializedNavigationDriver::Get()->Sanitize(this);
 
   is_restored_ = true;
 
   return true;
 }
 
 // TODO(zea): perhaps sync state (scroll position, form entries, etc.) as well?
 // See http://crbug.com/67068.
 sync_pb::TabNavigation SerializedNavigationEntry::ToSyncData() const {
   sync_pb::TabNavigation sync_data;
   sync_data.set_virtual_url(virtual_url_.spec());
-  sync_data.set_referrer(referrer_url_.spec());
-  sync_data.set_referrer_policy(referrer_policy_);
+  int mapped_referrer_policy;
+  if (SerializedNavigationDriver::Get()->MapReferrerPolicyToOldValues(
+          referrer_policy_, &mapped_referrer_policy)) {
+    sync_data.set_referrer(referrer_url_.spec());
+  } else {
+    sync_data.set_referrer(std::string());
+  }
+  sync_data.set_referrer_policy(mapped_referrer_policy);
+  sync_data.set_correct_referrer_policy(referrer_policy_);
   sync_data.set_title(base::UTF16ToUTF8(title_));
 
   // Page transition core.
   static_assert(ui::PAGE_TRANSITION_LAST_CORE ==
                 ui::PAGE_TRANSITION_KEYWORD_GENERATED,
                 "PAGE_TRANSITION_LAST_CORE must equal "
                 "PAGE_TRANSITION_KEYWORD_GENERATED");
   switch (ui::PageTransitionStripQualifier(transition_type_)) {
     case ui::PAGE_TRANSITION_LINK:
       sync_data.set_page_transition(
@@ skipping 102 matching lines @@
           redirect_chain_[last_entry].spec());
     }
   }
 
   sync_data.set_is_restored(is_restored_);
 
   return sync_data;
 }
 
 }  // namespace sessions