Re-implement PageState serialization without a Blink API dependency.

content/public/common/page_state.cc

Index: content/public/common/page_state.cc
diff --git a/content/public/common/page_state.cc b/content/public/common/page_state.cc
index 7daaaac6546e046ac83bbd7968413e0bbba4b6ae..0774200890b31c2737e8e2ef0c3ca6b0c77a13ff 100644
--- a/content/public/common/page_state.cc
+++ b/content/public/common/page_state.cc
@@ -4,13 +4,96 @@
 
 #include "content/public/common/page_state.h"
 
+#include "base/files/file_path.h"
+#include "base/strings/utf_string_conversions.h"
+#include "content/common/page_state_serialization.h"
+
 namespace content {
+namespace {
+
+base::NullableString16 ToNullableString16(const std::string& utf8) {
+  return base::NullableString16(UTF8ToUTF16(utf8), false);
+}
+
+base::FilePath ToFilePath(const base::NullableString16& s) {
+  return base::FilePath::FromUTF8Unsafe(UTF16ToUTF8(s.string()));
+}
+
+void ToFilePathVector(const std::vector<base::NullableString16>& input,
+                      std::vector<base::FilePath>* output) {
+  output->reserve(input.size());
+  for (size_t i = 0; i < input.size(); ++i)
+    output->push_back(ToFilePath(input[i]));
+}
+
+PageState ToPageState(const ExplodedPageState& state) {
+  std::string encoded_data;
+  if (!EncodePageState(state, &encoded_data))
+    return PageState();
+
+  return PageState::CreateFromEncodedData(encoded_data);
+}
+
+void RecursivelyRemovePasswordData(ExplodedFrameState* state) {
+  if (state->http_body.contains_passwords)
+    state->http_body = ExplodedHttpBody();
+}
+
+void RecursivelyRemoveScrollOffset(ExplodedFrameState* state) {
+  state->scroll_offset = gfx::Point();
+}
+
+}  // namespace
 
 // static
 PageState PageState::CreateFromEncodedData(const std::string& data) {
   return PageState(data);
 }
 
+// static
+PageState PageState::CreateFromURL(const GURL& url) {
+  ExplodedPageState state;
+
+  state.top.url_string = state.top.original_url_string =
+      ToNullableString16(url.possibly_invalid_spec());
+
+  return ToPageState(state);
+}
+
+// static
+PageState PageState::CreateForTesting(
+    const GURL& url,
+    bool body_contains_password_data,
+    const char* optional_body_data,
+    const base::FilePath* optional_body_file_path) {
+  ExplodedPageState state;
+
+  state.top.url_string = state.top.original_url_string =
+      ToNullableString16(url.possibly_invalid_spec());
+
+  if (optional_body_data || optional_body_file_path) {
+    state.top.http_body.is_null = false;
+    if (optional_body_data) {
+      ExplodedHttpBodyElement element;
+      element.type = WebKit::WebHTTPBody::Element::TypeData;
+      element.data = optional_body_data;
+      state.top.http_body.elements.push_back(element);
+    }
+    if (optional_body_file_path) {
+      ExplodedHttpBodyElement element;
+      element.type = WebKit::WebHTTPBody::Element::TypeFile;
+      element.file_path =
+          ToNullableString16(optional_body_file_path->AsUTF8Unsafe());
+      state.top.http_body.elements.push_back(element);
+      state.referenced_files.push_back(element.file_path);
+    }
+    state.top.http_body.contains_passwords =
+        body_contains_password_data;
+  }
+
+  return ToPageState(state);
+}
+
 PageState::PageState() {
 }
 
@@ -26,6 +109,36 @@ const std::string& PageState::ToEncodedData() const {
   return data_;
 }
 
+std::vector<base::FilePath> PageState::GetReferencedFiles() const {
+  std::vector<base::FilePath> results;
+
+  ExplodedPageState state;
+  if (DecodePageState(data_, &state))
+    ToFilePathVector(state.referenced_files, &results);
+
+  return results;
+}
+
+PageState PageState::RemovePasswordData() const {
+  ExplodedPageState state;
+  if (!DecodePageState(data_, &state))
+    return PageState();  // Oops!
+
+  RecursivelyRemovePasswordData(&state.top);
+
+  return ToPageState(state);
+}
+
+PageState PageState::RemoveScrollOffset() const {
+  ExplodedPageState state;
+  if (!DecodePageState(data_, &state))
+    return PageState();  // Oops!
+
+  RecursivelyRemoveScrollOffset(&state.top);
+
+  return ToPageState(state);
+}
+
 PageState::PageState(const std::string& data)
     : data_(data) {

[jamesr, 2013/06/21 23:32:31]

sorry, one more thing - if we receive an IPC message with a bad page state, it
looks like we store the string and the only detect that it represents something
bad when we try to ask questions of it. should we proactively attempt to decode
it when receiving the IPC message and then return false from the handler if we
couldn't parse it so we kill the sender? or is that too paranoid?

   // TODO(darin): Enable this DCHECK once tests have been fixed up to not pass