android_webview/native/state_serializer.cc

   1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "android_webview/native/state_serializer.h"
   6
   7 #include <string>
   8
   9 #include "base/memory/scoped_vector.h"
  10 #include "base/pickle.h"
  11 #include "base/time.h"
  12 #include "content/public/browser/navigation_controller.h"
  13 #include "content/public/browser/navigation_entry.h"
  14 #include "content/public/browser/web_contents.h"
  15 #include "content/public/common/page_state.h"
  16
  17 // Reasons for not re-using TabNavigation under chrome/ as of 20121116:
  18 // * Android WebView has different requirements for fields to store since
  19 //   we are the only ones using values like BaseURLForDataURL.
  20 // * TabNavigation does unnecessary copying of data, which in Android
  21 //   WebView case, is undesired since save/restore is called in Android
  22 //   very frequently.
  23 // * TabNavigation is tightly integrated with the rest of chrome session
  24 //   restore and sync code, and has other purpose in addition to serializing
  25 //   NavigationEntry.
  26
  27 using std::string;
  28
  29 namespace android_webview {
  30
  31 namespace {
  32
  33 // Sanity check value that we are restoring from a valid pickle.
  34 // This can potentially used as an actual serialization version number in the
  35 // future if we ever decide to support restoring from older versions.
  36 const uint32 AW_STATE_VERSION = 20121126;
  37
  38 }  // namespace
  39
  40 bool WriteToPickle(const content::WebContents& web_contents,
  41                    Pickle* pickle) {
  42   DCHECK(pickle);
  43
  44   if (!internal::WriteHeaderToPickle(pickle))
  45     return false;
  46
  47   const content::NavigationController& controller =
  48       web_contents.GetController();
  49   const int entry_count = controller.GetEntryCount();
  50   const int selected_entry = controller.GetCurrentEntryIndex();
  51   DCHECK(entry_count >= 0);
  52   DCHECK(selected_entry >= -1);  // -1 is valid
  53   DCHECK(selected_entry < entry_count);
  54
  55   if (!pickle->WriteInt(entry_count))
  56     return false;
  57
  58   if (!pickle->WriteInt(selected_entry))
  59     return false;
  60
  61   for (int i = 0; i < entry_count; ++i) {
  62     if (!internal::WriteNavigationEntryToPickle(*controller.GetEntryAtIndex(i),
  63                                                 pickle))
  64       return false;
  65   }
  66
  67   // Please update AW_STATE_VERSION if serialization format is changed.
  68
  69   return true;
  70 }
  71
  72 bool RestoreFromPickle(PickleIterator* iterator,
  73                        content::WebContents* web_contents) {
  74   DCHECK(iterator);
  75   DCHECK(web_contents);
  76
  77   if (!internal::RestoreHeaderFromPickle(iterator))
  78     return false;
  79
  80   int entry_count = -1;
  81   int selected_entry = -2;  // -1 is a valid value
  82
  83   if (!iterator->ReadInt(&entry_count))
  84     return false;
  85
  86   if (!iterator->ReadInt(&selected_entry))
  87     return false;
  88
  89   if (entry_count < 0)
  90     return false;
  91   if (selected_entry < -1)
  92     return false;
  93   if (selected_entry >= entry_count)
  94     return false;
  95
  96   ScopedVector<content::NavigationEntry> restored_entries;
  97   for (int i = 0; i < entry_count; ++i) {
  98     restored_entries.push_back(content::NavigationEntry::Create());
  99     if (!internal::RestoreNavigationEntryFromPickle(iterator,
 100                                                     restored_entries[i]))
 101       return false;
 102
 103     restored_entries[i]->SetPageID(i);
 104   }
 105
 106   // |web_contents| takes ownership of these entries after this call.
 107   web_contents->GetController().Restore(
 108       selected_entry,
 109       content::NavigationController::RESTORE_LAST_SESSION_EXITED_CLEANLY,
 110       &restored_entries.get());
 111   DCHECK_EQ(0u, restored_entries.size());
 112
 113   return true;
 114 }
 115
 116 namespace internal {
 117
 118 bool WriteHeaderToPickle(Pickle* pickle) {
 119   return pickle->WriteUInt32(AW_STATE_VERSION);
 120 }
 121
 122 bool RestoreHeaderFromPickle(PickleIterator* iterator) {
 123   uint32 state_version = -1;
 124   if (!iterator->ReadUInt32(&state_version))
 125     return false;
 126
 127   if (AW_STATE_VERSION != state_version)
 128     return false;
 129
 130   return true;
 131 }
 132
 133 bool WriteNavigationEntryToPickle(const content::NavigationEntry& entry,
 134                                   Pickle* pickle) {
 135   if (!pickle->WriteString(entry.GetURL().spec()))
 136     return false;
 137
 138   if (!pickle->WriteString(entry.GetVirtualURL().spec()))
 139     return false;
 140
 141   const content::Referrer& referrer = entry.GetReferrer();
 142   if (!pickle->WriteString(referrer.url.spec()))
 143     return false;
 144   if (!pickle->WriteInt(static_cast<int>(referrer.policy)))
 145     return false;
 146
 147   if (!pickle->WriteString16(entry.GetTitle()))
 148     return false;
 149
 150   if (!pickle->WriteString(entry.GetPageState().ToEncodedData()))
 151     return false;
 152
 153   if (!pickle->WriteBool(static_cast<int>(entry.GetHasPostData())))
 154     return false;
 155
 156   if (!pickle->WriteString(entry.GetOriginalRequestURL().spec()))
 157     return false;
 158
 159   if (!pickle->WriteString(entry.GetBaseURLForDataURL().spec()))
 160     return false;
 161
 162   if (!pickle->WriteBool(static_cast<int>(entry.GetIsOverridingUserAgent())))
 163     return false;
 164
 165   if (!pickle->WriteInt64(entry.GetTimestamp().ToInternalValue()))
 166     return false;
 167
 168   // Please update AW_STATE_VERSION if serialization format is changed.
 169
 170   return true;
 171 }
 172
 173 bool RestoreNavigationEntryFromPickle(PickleIterator* iterator,
 174                                       content::NavigationEntry* entry) {
 175   {
 176     string url;
 177     if (!iterator->ReadString(&url))
 178       return false;
 179     entry->SetURL(GURL(url));
 180   }
 181
 182   {
 183     string virtual_url;
 184     if (!iterator->ReadString(&virtual_url))
 185       return false;
 186     entry->SetVirtualURL(GURL(virtual_url));
 187   }
 188
 189   {
 190     content::Referrer referrer;
 191     string referrer_url;
 192     int policy;
 193
 194     if (!iterator->ReadString(&referrer_url))
 195       return false;
 196     if (!iterator->ReadInt(&policy))
 197       return false;
 198
 199     referrer.url = GURL(referrer_url);
 200     referrer.policy = static_cast<WebKit::WebReferrerPolicy>(policy);
 201     entry->SetReferrer(referrer);
 202   }
 203
 204   {
 205     string16 title;
 206     if (!iterator->ReadString16(&title))
 207       return false;
 208     entry->SetTitle(title);
 209   }
 210
 211   {
 212     string content_state;
 213     if (!iterator->ReadString(&content_state))
 214       return false;
 215     entry->SetPageState(
 216         content::PageState::CreateFromEncodedData(content_state));
 217   }
 218
 219   {
 220     bool has_post_data;
 221     if (!iterator->ReadBool(&has_post_data))
 222       return false;
 223     entry->SetHasPostData(has_post_data);
 224   }
 225
 226   {
 227     string original_request_url;
 228     if (!iterator->ReadString(&original_request_url))
 229       return false;
 230     entry->SetOriginalRequestURL(GURL(original_request_url));
 231   }
 232
 233   {
 234     string base_url_for_data_url;
 235     if (!iterator->ReadString(&base_url_for_data_url))
 236       return false;
 237     entry->SetBaseURLForDataURL(GURL(base_url_for_data_url));
 238   }
 239
 240   {
 241     bool is_overriding_user_agent;
 242     if (!iterator->ReadBool(&is_overriding_user_agent))
 243       return false;
 244     entry->SetIsOverridingUserAgent(is_overriding_user_agent);
 245   }
 246
 247   {
 248     int64 timestamp;
 249     if (!iterator->ReadInt64(&timestamp))
 250       return false;
 251     entry->SetTimestamp(base::Time::FromInternalValue(timestamp));
 252   }
 253
 254   return true;
 255 }
 256
 257 }  // namespace internal
 258
 259 }  // namespace android_webview