Make AW state_serializer handle restoring also legacy format

android_webview/native/state_serializer.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 "android_webview/native/state_serializer.h"
 
 #include <string>
 
 #include "base/pickle.h"
 #include "base/time/time.h"
@@ skipping 13 matching lines @@
 // * TabNavigation is tightly integrated with the rest of chrome session
 //   restore and sync code, and has other purpose in addition to serializing
 //   NavigationEntry.
 
 using std::string;
 
 namespace android_webview {
 
 namespace {
 
-// Sanity check value that we are restoring from a valid pickle.
-// This can potentially used as an actual serialization version number in the
-// future if we ever decide to support restoring from older versions.
-const uint32_t AW_STATE_VERSION = 20151204;
+const uint32_t AW_STATE_VERSION = internal::AW_STATE_VERSION_DATA_URL;
 
 }  // namespace
 
 bool WriteToPickle(const content::WebContents& web_contents,
                    base::Pickle* pickle) {
   DCHECK(pickle);
 
   if (!internal::WriteHeaderToPickle(pickle))
     return false;
 
@@ skipping 10 matching lines @@
 
   if (!pickle->WriteInt(selected_entry))
     return false;
 
   for (int i = 0; i < entry_count; ++i) {
     if (!internal::WriteNavigationEntryToPickle(*controller.GetEntryAtIndex(i),
                                                 pickle))
       return false;
   }
 
-  // Please update AW_STATE_VERSION if serialization format is changed.
+  // Please update AW_STATE_VERSION and IsSupportedVersion() if serialization
+  // format is changed.
+  // Make sure the serialization format is updated in a backwards compatible
+  // way.
 
   return true;
 }
 
 bool RestoreFromPickle(base::PickleIterator* iterator,
                        content::WebContents* web_contents) {
   DCHECK(iterator);
   DCHECK(web_contents);
 
-  if (!internal::RestoreHeaderFromPickle(iterator))
+  uint32_t state_version = internal::RestoreHeaderFromPickle(iterator);
+  if (!state_version)
     return false;
 
   int entry_count = -1;
   int selected_entry = -2;  // -1 is a valid value
 
   if (!iterator->ReadInt(&entry_count))
     return false;
 
   if (!iterator->ReadInt(&selected_entry))
     return false;
 
   if (entry_count < 0)
     return false;
   if (selected_entry < -1)
     return false;
   if (selected_entry >= entry_count)
     return false;
 
   std::vector<scoped_ptr<content::NavigationEntry>> entries;
   entries.reserve(entry_count);
   for (int i = 0; i < entry_count; ++i) {
     entries.push_back(content::NavigationEntry::Create());
-    if (!internal::RestoreNavigationEntryFromPickle(iterator, entries[i].get()))
+    if (!internal::RestoreNavigationEntryFromPickle(state_version, iterator,
+                                                    entries[i].get()))
       return false;
 
     entries[i]->SetPageID(i);
   }
 
   // |web_contents| takes ownership of these entries after this call.
   content::NavigationController& controller = web_contents->GetController();
   controller.Restore(
       selected_entry,
       content::NavigationController::RESTORE_LAST_SESSION_EXITED_CLEANLY,
@@ skipping 17 matching lines @@
   }
 
   controller.LoadIfNecessary();
 
   return true;
 }
 
 namespace internal {
 
 bool WriteHeaderToPickle(base::Pickle* pickle) {
-  return pickle->WriteUInt32(AW_STATE_VERSION);
+  return WriteHeaderToPickle(AW_STATE_VERSION, pickle);
 }
 
-bool RestoreHeaderFromPickle(base::PickleIterator* iterator) {
+bool WriteHeaderToPickle(uint32_t state_version, base::Pickle* pickle) {
+  return pickle->WriteUInt32(state_version);
+}
+
+uint32_t RestoreHeaderFromPickle(base::PickleIterator* iterator) {
   uint32_t state_version = -1;
   if (!iterator->ReadUInt32(&state_version))
-    return false;
+    return 0;
 
-  if (AW_STATE_VERSION != state_version)
-    return false;
+  if (IsSupportedVersion(state_version)) {
+    return state_version;
+  }
 
-  return true;
+  return 0;
+}
+
+bool IsSupportedVersion(uint32_t state_version) {
+  return state_version == internal::AW_STATE_VERSION_INITIAL ||
+         state_version == internal::AW_STATE_VERSION_DATA_URL;
 }
 
 bool WriteNavigationEntryToPickle(const content::NavigationEntry& entry,
                                   base::Pickle* pickle) {
+  return WriteNavigationEntryToPickle(AW_STATE_VERSION, entry, pickle);
+}
+
+bool WriteNavigationEntryToPickle(uint32_t state_version,
+                                  const content::NavigationEntry& entry,
+                                  base::Pickle* pickle) {
+  DCHECK(IsSupportedVersion(state_version));
   if (!pickle->WriteString(entry.GetURL().spec()))
     return false;
 
   if (!pickle->WriteString(entry.GetVirtualURL().spec()))
     return false;
 
   const content::Referrer& referrer = entry.GetReferrer();
   if (!pickle->WriteString(referrer.url.spec()))
     return false;
   if (!pickle->WriteInt(static_cast<int>(referrer.policy)))
     return false;
 
   if (!pickle->WriteString16(entry.GetTitle()))
     return false;
 
   if (!pickle->WriteString(entry.GetPageState().ToEncodedData()))
     return false;
 
   if (!pickle->WriteBool(static_cast<int>(entry.GetHasPostData())))
     return false;
 
   if (!pickle->WriteString(entry.GetOriginalRequestURL().spec()))
     return false;
 
   if (!pickle->WriteString(entry.GetBaseURLForDataURL().spec()))
     return false;
 
-  {
+  if (state_version >= internal::AW_STATE_VERSION_DATA_URL) {
     const char* data = nullptr;
     size_t size = 0;
     scoped_refptr<const base::RefCountedString> s = entry.GetDataURLAsString();
     if (s) {
       data = s->front_as<char>();
       size = s->size();
     }
     // Even when |entry.GetDataForDataURL()| is null we still need to write a
     // zero-length entry to ensure the fields all line up when read back in.
     if (!pickle->WriteData(data, size))
       return false;
   }
 
   if (!pickle->WriteBool(static_cast<int>(entry.GetIsOverridingUserAgent())))
     return false;
 
   if (!pickle->WriteInt64(entry.GetTimestamp().ToInternalValue()))
     return false;
 
   if (!pickle->WriteInt(entry.GetHttpStatusCode()))
     return false;
 
-  // Please update AW_STATE_VERSION if serialization format is changed.
+  // Please update AW_STATE_VERSION and IsSupportedVersion() if serialization
+  // format is changed.
+  // Make sure the serialization format is updated in a backwards compatible
+  // way.
 
   return true;
 }
 
 bool RestoreNavigationEntryFromPickle(base::PickleIterator* iterator,
                                       content::NavigationEntry* entry) {
+  return RestoreNavigationEntryFromPickle(AW_STATE_VERSION, iterator, entry);
+}
+
+bool RestoreNavigationEntryFromPickle(uint32_t state_version,
+                                      base::PickleIterator* iterator,
+                                      content::NavigationEntry* entry) {
+  DCHECK(IsSupportedVersion(state_version));
   {
     string url;
     if (!iterator->ReadString(&url))
       return false;
     entry->SetURL(GURL(url));
   }
 
   {
     string virtual_url;
     if (!iterator->ReadString(&virtual_url))
@@ skipping 45 matching lines @@
     entry->SetOriginalRequestURL(GURL(original_request_url));
   }
 
   {
     string base_url_for_data_url;
     if (!iterator->ReadString(&base_url_for_data_url))
       return false;
     entry->SetBaseURLForDataURL(GURL(base_url_for_data_url));
   }
 
-  {
+  if (state_version >= internal::AW_STATE_VERSION_DATA_URL) {
     const char* data;
     int size;
     if (!iterator->ReadData(&data, &size))
       return false;
     if (size > 0) {
       scoped_refptr<base::RefCountedString> ref = new base::RefCountedString();
       ref->data().assign(data, size);
       entry->SetDataURLAsString(ref);
     }
   }
@@ skipping 18 matching lines @@
       return false;
     entry->SetHttpStatusCode(http_status_code);
   }
 
   return true;
 }
 
 }  // namespace internal
 
 }  // namespace android_webview