Merge lp:~osomon/oxide/save-restore-state into lp:~oxide-developers/oxide/oxide.trunk

[Olivier Tilloy]

Expose an API to save/restore the current state of a webview.

[Chris Coulson (chrisccoulson)]

Thanks for working on this. I have some general comments (I mentioned these the other day):

- I've been thinking about how we would adapt this in the future to provide a way to restore from a crash. Doing this requires continuous updating of the persistent state, which means that my original suggestion to use a function to access the serialized state (as opposed to a notifiable property) in order to avoid applications binding to it (and requiring us to serialize the data continuously) may not actually be the best approach. In fact, I think that being able to do continuous updates would require this to a notifiable property.

I would be tempted to convert this to a property, but ensure that the browser only polls it at shutdown for now - at least until we've evaluated to the performance impact of serializing the full state, and maybe figured out a way to do incremental updates.

- I'd add a magic number and version to the start of the serialized data. This would future-proof it if we found a need to modify the contents later on (eg, adding support for storage partitions), and would allow us to handle upgrades from old data formats gracefully.

- WebView.currentState is fine, but I'd rename WebView.state to WebView.restoreState or something like that.

- Based on the assumption that we eventually want crash-restore, it might be worth exposing WebView.restoreType (mapping to content::NavigationController::RestoreType). There is, at least, a difference between RESTORE_LAST_SESSION_EXITED_CLEANLY and the other 2 enums (it does a cache-only load for a page with POST-data). The difference between RESTORE_CURRENT and RESTORE_LAST_SESSION_CRASHED seems to be only in metrics data (which we don't use), but it's probably worth exposing them separately anyway because we wouldn't want to have to use "RestoreTypeLastSessionCrashed" for a tab restored from the current session.

- Note that r855 probably breaks this a bit (I've moved all of the construct properties to WebViewAdapter::init()).

review: Needs Fixing

[lp:~osomon/oxide/save-restore-state]

800. By Olivier Tilloy on 2014-11-18

Merge the latest changes from trunk.

801. By Olivier Tilloy on 2014-11-18

Rename the 'state' property to 'restoreState'.

802. By Olivier Tilloy on 2014-11-18

Make currentState a read-only property, instead of a method.

803. By Olivier Tilloy on 2014-11-18

Add a magic number and a version to the serialized state.

804. By Olivier Tilloy on 2014-11-19

Expose WebView.restoreType.

[Olivier Tilloy (osomon)]

Updated to address all your comments.

[Chris Coulson (chrisccoulson)]

Thanks, that looks fine now. One thing I should have mentioned last time is that the new properties should be annotated with a revision number (in this case, 2). Other than that, this is fine to merge

review: Approve

[lp:~osomon/oxide/save-restore-state]

805. By Olivier Tilloy on 2014-11-20

Version the new properties (will be available starting with oxide 1.4).

=== modified file 'qt/core/glue/oxide_qt_web_view_adapter.cc'
--- qt/core/glue/oxide_qt_web_view_adapter.cc	2014-11-13 09:17:40 +0000
+++ qt/core/glue/oxide_qt_web_view_adapter.cc	2014-11-20 12:42:26 +0000
@@ -17,12 +17,15 @@
 
 #include "oxide_qt_web_view_adapter.h"
 
+#include <limits>
+
 #include <QSize>
 #include <QtDebug>
 
 #include "base/logging.h"
 #include "base/macros.h"
 #include "base/memory/ref_counted.h"
+#include "base/pickle.h"
 #include "cc/output/compositor_frame_metadata.h"
 #include "ui/gfx/size.h"
 #include "url/gurl.h"
@@ -44,6 +47,11 @@
 namespace oxide {
 namespace qt {
 
+namespace {
+static const char* STATE_SERIALIZER_MAGIC_NUMBER = "oxide";
+static uint16_t STATE_SERIALIZER_VERSION = 1;
+}
+
 class CompositorFrameHandleImpl : public CompositorFrameHandle {
  public:
   CompositorFrameHandleImpl(oxide::CompositorFrameHandle* frame)
@@ -104,6 +112,70 @@
       OxideQWebPreferencesPrivate::get(p)->preferences());
 }
 
+void WebViewAdapter::RestoreState(RestoreType type, const QByteArray& state) {
+  COMPILE_ASSERT(
+      RESTORE_CURRENT_SESSION == static_cast<RestoreType>(
+          content::NavigationController::RESTORE_CURRENT_SESSION),
+      restore_type_enums_current_doesnt_match);
+  COMPILE_ASSERT(
+      RESTORE_LAST_SESSION_EXITED_CLEANLY == static_cast<RestoreType>(
+          content::NavigationController::RESTORE_LAST_SESSION_EXITED_CLEANLY),
+      restore_type_enums_exited_cleanly_doesnt_match);
+  COMPILE_ASSERT(
+      RESTORE_LAST_SESSION_CRASHED == static_cast<RestoreType>(
+          content::NavigationController::RESTORE_LAST_SESSION_CRASHED),
+      restore_type_enums_crashed_doesnt_match);
+
+  content::NavigationController::RestoreType restore_type =
+      static_cast<content::NavigationController::RestoreType>(type);
+
+#define WARN_INVALID_DATA \
+    qWarning() << "Failed to read initial state: invalid data"
+  std::vector<sessions::SerializedNavigationEntry> entries;
+  Pickle pickle(state.data(), state.size());
+  PickleIterator i(pickle);
+  std::string magic_number;
+  if (!i.ReadString(&magic_number)) {
+    WARN_INVALID_DATA;
+    return;
+  }
+  if (magic_number != STATE_SERIALIZER_MAGIC_NUMBER) {
+    WARN_INVALID_DATA;
+    return;
+  }
+  uint16_t version;
+  if (!i.ReadUInt16(&version)) {
+    WARN_INVALID_DATA;
+    return;
+  }
+  if (version != STATE_SERIALIZER_VERSION) {
+    WARN_INVALID_DATA;
+    return;
+  }
+  int count;
+  if (!i.ReadLength(&count)) {
+    WARN_INVALID_DATA;
+    return;
+  }
+  entries.resize(count);
+  for (int j = 0; j < count; ++j) {
+    sessions::SerializedNavigationEntry entry;
+    if (!entry.ReadFromPickle(&i)) {
+      WARN_INVALID_DATA;
+      return;
+    }
+    entries[j] = entry;
+  }
+  int index;
+  if (!i.ReadInt(&index)) {
+    WARN_INVALID_DATA;
+    return;
+  }
+#undef WARN_INVALID_DATA
+
+  view_->SetState(restore_type, entries, index);
+}
+
 void WebViewAdapter::Initialized() {
   DCHECK(isInitialized());
 
@@ -134,7 +206,9 @@
 
 void WebViewAdapter::init(bool incognito,
                           WebContextAdapter* context,
-                          OxideQNewViewRequest* new_view_request) {
+                          OxideQNewViewRequest* new_view_request,
+                          const QByteArray& restoreState,
+                          RestoreType restoreType) {
   DCHECK(!isInitialized());
 
   bool script_opened = false;
@@ -155,6 +229,10 @@
     return;
   }
 
+  if (!restoreState.isEmpty()) {
+    RestoreState(restoreType, restoreState);
+  }
+
   CHECK(context) <<
       "No context available for WebView. If you see this when running in "
       "single-process mode, it is possible that the default WebContext has "
@@ -325,6 +403,24 @@
       view_->GetNavigationEntryTimestamp(index).ToJsTime());
 }
 
+QByteArray WebViewAdapter::currentState() const {
+  std::vector<sessions::SerializedNavigationEntry> entries = view_->GetState();
+  if (entries.size() == 0) {
+    return QByteArray();
+  }
+  Pickle pickle;
+  pickle.WriteString(STATE_SERIALIZER_MAGIC_NUMBER);
+  pickle.WriteUInt16(STATE_SERIALIZER_VERSION);
+  pickle.WriteInt(entries.size());
+  std::vector<sessions::SerializedNavigationEntry>::const_iterator i;
+  static const size_t max_state_size = std::numeric_limits<uint16>::max() - 1024;
+  for (i = entries.begin(); i != entries.end(); ++i) {
+    i->WriteToPickle(max_state_size, &pickle);
+  }
+  pickle.WriteInt(view_->GetNavigationCurrentEntryIndex());
+  return QByteArray(static_cast<const char*>(pickle.data()), pickle.size());
+}
+
 OxideQWebPreferences* WebViewAdapter::preferences() {
   EnsurePreferences();
   return static_cast<WebPreferences*>(

=== modified file 'qt/core/glue/oxide_qt_web_view_adapter.h'
--- qt/core/glue/oxide_qt_web_view_adapter.h	2014-11-13 00:34:18 +0000
+++ qt/core/glue/oxide_qt_web_view_adapter.h	2014-11-20 12:42:26 +0000
@@ -18,6 +18,7 @@
 #ifndef _OXIDE_QT_CORE_GLUE_WEB_VIEW_ADAPTER_H_
 #define _OXIDE_QT_CORE_GLUE_WEB_VIEW_ADAPTER_H_
 
+#include <QByteArray>
 #include <QDateTime>
 #include <QImage>
 #include <QList>
@@ -85,6 +86,12 @@
   CONTENT_TYPE_MIXED_SCRIPT = 1 << 1
 };
 
+enum RestoreType {
+  RESTORE_CURRENT_SESSION,
+  RESTORE_LAST_SESSION_EXITED_CLEANLY,
+  RESTORE_LAST_SESSION_CRASHED,
+};
+
 class Q_DECL_EXPORT AcceleratedFrameData final {
  public:
   AcceleratedFrameData(unsigned int id)
@@ -120,7 +127,9 @@
 
   void init(bool incognito,
             WebContextAdapter* context,
-            OxideQNewViewRequest* new_view_request);
+            OxideQNewViewRequest* new_view_request,
+            const QByteArray& restoreState,
+            RestoreType restoreType);
 
   QUrl url() const;
   void setUrl(const QUrl& url);
@@ -171,6 +180,8 @@
   QString getNavigationEntryTitle(int index) const;
   QDateTime getNavigationEntryTimestamp(int index) const;
 
+  QByteArray currentState() const;
+
   OxideQWebPreferences* preferences();
   void setPreferences(OxideQWebPreferences* prefs);
 
@@ -201,6 +212,7 @@
   friend class WebView;
 
   void EnsurePreferences();
+  void RestoreState(RestoreType type, const QByteArray& state);
 
   void Initialized();
   void WebPreferencesDestroyed();

=== modified file 'qt/quick/api/oxideqquickwebview.cc'
--- qt/quick/api/oxideqquickwebview.cc	2014-11-13 09:17:40 +0000
+++ qt/quick/api/oxideqquickwebview.cc	2014-11-20 12:42:26 +0000
@@ -18,6 +18,7 @@
 #include "oxideqquickwebview_p.h"
 #include "oxideqquickwebview_p_p.h"
 
+#include <QByteArray>
 #include <QEvent>
 #include <QFlags>
 #include <QGuiApplication>
@@ -656,7 +657,9 @@
 
   init(construct_props_->incognito,
        context ? OxideQQuickWebContextPrivate::get(context) : NULL,
-       construct_props_->new_view_request);
+       construct_props_->new_view_request,
+       construct_props_->restore_state,
+       construct_props_->restore_type);
 }
 
 // static
@@ -1432,6 +1435,64 @@
   d->construct_props_->new_view_request = request;
 }
 
+// This exists purely to remove a moc warning. We don't store this initial state
+// anywhere, it's only a transient blob and I can't think of any possible
+// reason why anybody would want to read it back
+QString OxideQQuickWebView::restoreState() const {
+  return QString();
+}
+
+void OxideQQuickWebView::setRestoreState(const QString& state) {
+  Q_D(OxideQQuickWebView);
+
+  if (d->isInitialized()) {
+    qWarning() << "Cannot assign state to an already constructed WebView";
+    return;
+  }
+
+  // state is expected to be a base64-encoded string
+  d->construct_props_->restore_state =
+      QByteArray::fromBase64(state.toLocal8Bit());
+}
+
+// This exists purely to remove a moc warning. We don't store this restore type
+// anywhere, it's only a transient property and I can't think of any possible
+// reason why anybody would want to read it back
+OxideQQuickWebView::RestoreType OxideQQuickWebView::restoreType() const {
+  Q_D(const OxideQQuickWebView);
+
+  return RestoreLastSessionExitedCleanly;
+}
+
+void OxideQQuickWebView::setRestoreType(OxideQQuickWebView::RestoreType type) {
+  Q_D(OxideQQuickWebView);
+
+  if (d->isInitialized()) {
+    qWarning() << "Cannot assign state to an already constructed WebView";
+    return;
+  }
+
+  Q_STATIC_ASSERT(
+      RestoreCurrentSession ==
+        static_cast<RestoreType>(oxide::qt::RESTORE_CURRENT_SESSION));
+  Q_STATIC_ASSERT(
+      RestoreLastSessionExitedCleanly ==
+        static_cast<RestoreType>(oxide::qt::RESTORE_LAST_SESSION_EXITED_CLEANLY));
+  Q_STATIC_ASSERT(
+      RestoreLastSessionCrashed ==
+        static_cast<RestoreType>(oxide::qt::RESTORE_LAST_SESSION_CRASHED));
+
+  d->construct_props_->restore_type = static_cast<oxide::qt::RestoreType>(type);
+}
+
+QString OxideQQuickWebView::currentState() const {
+  Q_D(const OxideQQuickWebView);
+
+  // Encode the current state in base64 so it can be safely passed around
+  // as a string (QML doesn’t know of byte arrays)
+  return QString::fromLocal8Bit(d->currentState().toBase64());
+}
+
 // static
 OxideQQuickWebViewAttached* OxideQQuickWebView::qmlAttachedProperties(
     QObject* object) {

=== modified file 'qt/quick/api/oxideqquickwebview_p.h'
--- qt/quick/api/oxideqquickwebview_p.h	2014-11-06 16:55:49 +0000
+++ qt/quick/api/oxideqquickwebview_p.h	2014-11-20 12:42:26 +0000
@@ -67,6 +67,7 @@
 
   Q_FLAGS(ContentType)
   Q_ENUMS(LogMessageSeverityLevel);
+  Q_ENUMS(RestoreType);
 
   Q_PROPERTY(QUrl url READ url WRITE setUrl NOTIFY urlChanged)
   Q_PROPERTY(QString title READ title NOTIFY titleChanged)
@@ -106,6 +107,14 @@
 
   Q_PROPERTY(OxideQNewViewRequest* request READ request WRITE setRequest)
 
+  // Set at construction time only
+  Q_PROPERTY(QString restoreState READ restoreState WRITE setRestoreState REVISION 2)
+  Q_PROPERTY(RestoreType restoreType READ restoreType WRITE setRestoreType REVISION 2)
+  // Use to query the current state, to restore later
+  // XXX: not notify-able for now, until we figure out a way
+  // to do incremental updates
+  Q_PROPERTY(QString currentState READ currentState REVISION 2)
+
   Q_DECLARE_PRIVATE(OxideQQuickWebView)
 
  public:
@@ -130,6 +139,12 @@
   };
   Q_DECLARE_FLAGS(ContentType, ContentTypeFlags)
 
+  enum RestoreType {
+    RestoreCurrentSession,
+    RestoreLastSessionExitedCleanly,
+    RestoreLastSessionCrashed
+  };
+
   void componentComplete();
 
   QUrl url() const;
@@ -197,6 +212,12 @@
   OxideQNewViewRequest* request() const;
   void setRequest(OxideQNewViewRequest* request);
 
+  QString restoreState() const;
+  void setRestoreState(const QString& state);
+  RestoreType restoreType() const;
+  void setRestoreType(RestoreType type);
+  QString currentState() const;
+
   static OxideQQuickWebViewAttached* qmlAttachedProperties(QObject* object);
 
  public Q_SLOTS:

=== modified file 'qt/quick/api/oxideqquickwebview_p_p.h'
--- qt/quick/api/oxideqquickwebview_p_p.h	2014-11-13 00:34:18 +0000
+++ qt/quick/api/oxideqquickwebview_p_p.h	2014-11-20 12:42:26 +0000
@@ -18,6 +18,7 @@
 #ifndef _OXIDE_QT_QUICK_API_WEB_VIEW_P_P_H_
 #define _OXIDE_QT_QUICK_API_WEB_VIEW_P_P_H_
 
+#include <QByteArray>
 #include <QPointer>
 #include <QScopedPointer>
 #include <QSharedPointer>
@@ -175,11 +176,14 @@
 
   struct ConstructProps {
     ConstructProps()
-        : incognito(false) {}
+        : incognito(false)
+        , restore_type(oxide::qt::RESTORE_LAST_SESSION_EXITED_CLEANLY) {}
 
     bool incognito;
     QPointer<OxideQQuickWebContext> context;
     QPointer<OxideQNewViewRequest> new_view_request;
+    QByteArray restore_state;
+    oxide::qt::RestoreType restore_type;
   };
 
   QScopedPointer<ConstructProps> construct_props_;

=== added file 'qt/tests/qmltests/api/tst_WebView_save_restore_form_data.html'
--- qt/tests/qmltests/api/tst_WebView_save_restore_form_data.html	1970-01-01 00:00:00 +0000
+++ qt/tests/qmltests/api/tst_WebView_save_restore_form_data.html	2014-11-20 12:42:26 +0000
@@ -0,0 +1,5 @@
+<html>
+<body>
+  <input type="text" id="textInput" autofocus="autofocus">
+</body>
+</html>

=== added file 'qt/tests/qmltests/api/tst_WebView_save_restore_state.qml'
--- qt/tests/qmltests/api/tst_WebView_save_restore_state.qml	1970-01-01 00:00:00 +0000
+++ qt/tests/qmltests/api/tst_WebView_save_restore_state.qml	2014-11-20 12:42:26 +0000
@@ -0,0 +1,152 @@
+import QtQuick 2.0
+import QtTest 1.0
+import com.canonical.Oxide 1.4
+import com.canonical.Oxide.Testing 1.0
+
+TestCase {
+  name: "WebView_save_restore_state"
+  when: windowShown
+  width: 200
+  height: 200
+
+  property var webView
+
+  Component {
+    id: webViewComponent
+
+    TestWebView {
+      focus: true
+      anchors.fill: parent
+    }
+  }
+
+  function get_restore_types() {
+    return [
+      {restoreType: WebView.RestoreCurrentSession},
+      {restoreType: WebView.RestoreLastSessionExitedCleanly},
+      {restoreType: WebView.RestoreLastSessionCrashed}
+    ];
+  }
+
+  function init() {
+    webView = webViewComponent.createObject(this);
+  }
+
+  function cleanup() {
+    webView.destroy()
+  }
+
+  function test_WebView_save_and_restore_current_page_data() {
+    return get_restore_types();
+  }
+
+  function test_WebView_save_and_restore_current_page(data) {
+    webView.url = "http://testsuite/tst_WebView_navigation1.html";
+    verify(webView.waitForLoadSucceeded(),
+           "Timed out waiting for successful load");
+
+    var state = webView.currentState;
+    verify(state.length > 0);
+
+    var restored = webViewComponent.createObject(
+        webView, {"restoreType": data.restoreType, "restoreState": state});
+    verify(restored !== null);
+    tryCompare(restored, "url", webView.url);
+    verify(restored.waitForLoadSucceeded(),
+           "Timed out waiting for successful load");
+    restored.destroy();
+  }
+
+  function test_WebView_save_and_restore_navigation_history_data() {
+    return get_restore_types();
+  }
+
+  function test_WebView_save_and_restore_navigation_history(data) {
+    webView.url = "http://testsuite/tst_WebView_navigation1.html";
+    verify(webView.waitForLoadSucceeded(),
+           "Timed out waiting for successful load");
+    webView.url = "http://testsuite/tst_WebView_navigation2.html";
+    verify(webView.waitForLoadSucceeded(),
+           "Timed out waiting for successful load");
+    webView.url = "http://testsuite/tst_WebView_navigation3.html";
+    verify(webView.waitForLoadSucceeded(),
+           "Timed out waiting for successful load");
+    webView.goBack();
+    verify(webView.waitForLoadSucceeded(),
+           "Timed out waiting for successful load");
+
+    var state = webView.currentState;
+    verify(state.length > 0);
+
+    var restored = webViewComponent.createObject(
+        webView, {"restoreType": data.restoreType, "restoreState": state});
+    verify(restored !== null);
+    tryCompare(restored, "url", webView.url);
+    verify(restored.waitForLoadSucceeded(),
+           "Timed out waiting for successful load");
+    verify(restored.canGoBack);
+    verify(restored.canGoForward);
+    compare(restored.navigationHistory.currentIndex, 1);
+    restored.destroy();
+  }
+
+  function test_WebView_save_and_restore_scroll_offset_data() {
+    return get_restore_types();
+  }
+
+  function test_WebView_save_and_restore_scroll_offset(data) {
+    webView.url = "http://testsuite/tst_WebView_flickableLikeAPI.html";
+    verify(webView.waitForLoadSucceeded(),
+           "Timed out waiting for successful load");
+    webView.getTestApi().evaluateCode("document.body.scrollLeft = 300");
+    webView.getTestApi().evaluateCode("document.body.scrollTop = 700");
+
+    var state = webView.currentState;
+    verify(state.length > 0);
+
+    var restored = webViewComponent.createObject(
+        webView, {"restoreType": data.restoreType, "restoreState": state});
+    verify(restored !== null);
+    tryCompare(restored, "url", webView.url);
+    verify(restored.waitForLoadSucceeded(),
+           "Timed out waiting for successful load");
+    restored.waitFor(function() {
+        return parseFloat(restored.getTestApi().evaluateCode(
+            "document.body.scrollLeft")) == 300; });
+    restored.waitFor(function() {
+        return parseFloat(restored.getTestApi().evaluateCode(
+            "document.body.scrollTop")) == 700; });
+    restored.destroy();
+  }
+
+  function test_WebView_save_and_restore_form_data_input_data() {
+    return get_restore_types();
+  }
+
+  function test_WebView_save_and_restore_form_data_input(data) {
+    webView.url = "http://testsuite/tst_WebView_save_restore_form_data.html";
+    verify(webView.waitForLoadSucceeded(),
+           "Timed out waiting for successful load");
+    keyClick("T");
+    keyClick("e");
+    keyClick("$");
+    keyClick("t");
+    webView.waitFor(function() {
+        return webView.getTestApi().evaluateCode(
+            "document.querySelector('#textInput').value") == "Te$t"; });
+
+    var state = webView.currentState;
+    verify(state.length > 0);
+
+    var restored = webViewComponent.createObject(
+        webView, {"restoreType": data.restoreType, "restoreState": state});
+    verify(restored !== null);
+    tryCompare(restored, "url", webView.url);
+    verify(restored.waitForLoadSucceeded(),
+           "Timed out waiting for successful load");
+    restored.waitFor(function() {
+        return restored.getTestApi().evaluateCode(
+            "document.querySelector('#textInput').value") == "Te$t"; });
+    restored.destroy();
+  }
+}

=== modified file 'shared/browser/oxide_web_view.cc'
--- shared/browser/oxide_web_view.cc	2014-11-08 00:28:36 +0000
+++ shared/browser/oxide_web_view.cc	2014-11-20 12:42:26 +0000
@@ -26,6 +26,7 @@
 #include "base/strings/string_util.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/supports_user_data.h"
+#include "components/sessions/content/content_serialized_navigation_builder.h"
 #include "content/browser/frame_host/frame_tree.h"
 #include "content/browser/frame_host/frame_tree_node.h"
 #include "content/browser/frame_host/render_frame_host_impl.h"
@@ -1154,6 +1155,8 @@
       compositor_(Compositor::Create(this, ShouldUseSoftwareCompositing())),
       gesture_provider_(GestureProvider::Create(this)),
       in_swap_(false),
+      restore_type_(content::NavigationController::RESTORE_LAST_SESSION_EXITED_CLEANLY),
+      initial_index_(0),
       root_frame_(NULL),
       is_fullscreen_(false),
       blocked_content_(CONTENT_TYPE_NONE),
@@ -1259,6 +1262,17 @@
         content::WebContents::Create(content_params)));
     CHECK(web_contents_.get()) << "Failed to create WebContents";
 
+    if (!restore_state_.empty()) {
+      ScopedVector<content::NavigationEntry> entries =
+          sessions::ContentSerializedNavigationBuilder::ToNavigationEntries(
+              restore_state_, context);
+      web_contents_->GetController().Restore(
+          initial_index_,
+          content::NavigationController::RESTORE_LAST_SESSION_EXITED_CLEANLY,
+          &entries.get());
+      restore_state_.clear();
+    }
+
     new WebViewContentsHelper(web_contents_.get());
 
     compositor_->SetViewportSize(GetViewSizePix());
@@ -1300,6 +1314,8 @@
     }
   }
 
+  web_contents_->GetController().LoadIfNecessary();
+
   SetIsFullscreen(is_fullscreen_);
 
   DCHECK(std::find(g_all_web_views.Get().begin(),
@@ -1353,6 +1369,36 @@
   web_contents_->GetController().LoadURLWithParams(params);
 }
 
+std::vector<sessions::SerializedNavigationEntry> WebView::GetState() const {
+  std::vector<sessions::SerializedNavigationEntry> entries;
+  if (!web_contents_) {
+    return entries;
+  }
+  const content::NavigationController& controller = web_contents_->GetController();
+  const int pending_index = controller.GetPendingEntryIndex();
+  int entry_count = controller.GetEntryCount();
+  if (entry_count == 0 && pending_index == 0) {
+    entry_count++;
+  }
+  entries.resize(entry_count);
+  for (int i = 0; i < entry_count; ++i) {
+    content::NavigationEntry* entry = (i == pending_index) ?
+        controller.GetPendingEntry() : controller.GetEntryAtIndex(i);
+    entries[i] =
+        sessions::ContentSerializedNavigationBuilder::FromNavigationEntry(i, *entry);
+  }
+  return entries;
+}
+
+void WebView::SetState(content::NavigationController::RestoreType type,
+                       std::vector<sessions::SerializedNavigationEntry> state,
+                       int index) {
+  DCHECK(!web_contents_);
+  restore_type_ = type;
+  restore_state_ = state;
+  initial_index_ = index;
+}
+
 void WebView::LoadData(const std::string& encodedData,
                        const std::string& mimeType,
                        const GURL& baseUrl) {

=== modified file 'shared/browser/oxide_web_view.h'
--- shared/browser/oxide_web_view.h	2014-11-07 20:31:37 +0000
+++ shared/browser/oxide_web_view.h	2014-11-20 12:42:26 +0000
@@ -30,6 +30,7 @@
 #include "base/strings/string16.h"
 #include "base/timer/timer.h"
 #include "cc/output/compositor_frame_metadata.h"
+#include "components/sessions/serialized_navigation_entry.h"
 #include "content/browser/renderer_host/event_with_latency_info.h"
 #include "content/common/input/input_event_ack_state.h"
 #include "content/public/browser/certificate_request_result_type.h"
@@ -146,6 +147,13 @@
  public:
   virtual ~WebView();
 
+  // Maps to content::NavigationController::RestoreType
+  enum RestoreType {
+    RESTORE_CURRENT_SESSION,
+    RESTORE_LAST_SESSION_EXITED_CLEANLY,
+    RESTORE_LAST_SESSION_CRASHED,
+  };
+
   struct Params {
     Params() :
         context(NULL),
@@ -167,6 +175,11 @@
   const GURL& GetURL() const;
   void SetURL(const GURL& url);
 
+  std::vector<sessions::SerializedNavigationEntry> GetState() const;
+  void SetState(content::NavigationController::RestoreType type,
+                std::vector<sessions::SerializedNavigationEntry> state,
+                int index);
+
   void LoadData(const std::string& encodedData,
                 const std::string& mimeType,
                 const GURL& baseUrl);
@@ -551,6 +564,9 @@
 
   GURL initial_url_;
   scoped_ptr<content::NavigationController::LoadURLParams> initial_data_;
+  content::NavigationController::RestoreType restore_type_;
+  std::vector<sessions::SerializedNavigationEntry> restore_state_;
+  int initial_index_;
 
   content::NotificationRegistrar registrar_;
   WebFrame* root_frame_;

=== modified file 'shared/shared.gyp'
--- shared/shared.gyp	2014-11-14 11:51:24 +0000
+++ shared/shared.gyp	2014-11-20 12:42:26 +0000
@@ -183,6 +183,7 @@
         '<(DEPTH)/build/linux/system.gyp:dbus',
         '<(DEPTH)/build/linux/system.gyp:fontconfig',
         '<(DEPTH)/cc/cc.gyp:cc',
+        '<(DEPTH)/components/components.gyp:sessions_content',
         '<(DEPTH)/content/content.gyp:content_app_both',
         '<(DEPTH)/content/content.gyp:content_browser',
         '<(DEPTH)/content/content.gyp:content_child',