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()) {

[Andrew T Wilson (Slow), 2015/01/29 11:02:13]

Does this mean that if you have an old client and you modify the referrer
policy, the change won't take effect on newer clients because they are only
looking at "correct_referrer_policy" now?

[jochen (gone - plz use gerrit), 2015/01/29 12:04:44]

The entries aren't modified by clients.

+    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)) {

[Andrew T Wilson (Slow), 2015/01/29 11:02:13]

Fine as-is, but I wonder if the following is easier to read:

if (SerializedNavigationDriver::Get()->Map...() && referrer_url_.is_valid()) {
  WriteStringToPickle(pickle, &bytes_written, max_size, referrer_url_.spec());
} else {
  WriteStringToPickle(pickle, &bytes_written, max_size, std::string());
}

+    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();

[marja, 2015/01/29 10:54:20]

Why do we want to do this also in the case where we do have a correct referrer
policy too?

[jochen (gone - plz use gerrit), 2015/01/29 10:59:31]

good point. moved this code block down.

+      }
+      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