1// Copyright 2014 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 "content/renderer/history_serialization.h"
6
7#include "content/common/page_state_serialization.h"
8#include "content/public/common/page_state.h"
9#include "content/renderer/history_entry.h"
10#include "third_party/WebKit/public/platform/WebFloatPoint.h"
11#include "third_party/WebKit/public/platform/WebHTTPBody.h"
12#include "third_party/WebKit/public/platform/WebPoint.h"
13#include "third_party/WebKit/public/platform/WebString.h"
14#include "third_party/WebKit/public/platform/WebVector.h"
15#include "third_party/WebKit/public/web/WebHistoryItem.h"
16#include "third_party/WebKit/public/web/WebSerializedScriptValue.h"
17
18using blink::WebHTTPBody;
19using blink::WebHistoryItem;
20using blink::WebSerializedScriptValue;
21using blink::WebString;
22using blink::WebVector;
23
24namespace content {
25namespace {
26
27void ToNullableString16Vector(const WebVector<WebString>& input,
28                              std::vector<base::NullableString16>* output) {
29  output->reserve(input.size());
30  for (size_t i = 0; i < input.size(); ++i)
31    output->push_back(input[i]);
32}
33
34void ToExplodedHttpBodyElement(const WebHTTPBody::Element& input,
35                               ExplodedHttpBodyElement* output) {
36  switch (input.type) {
37    case WebHTTPBody::Element::TypeData:
38      output->data.assign(input.data.data(), input.data.size());
39      break;
40    case WebHTTPBody::Element::TypeFile:
41      output->file_path = input.filePath;
42      output->file_start = input.fileStart;
43      output->file_length = input.fileLength;
44      output->file_modification_time = input.modificationTime;
45      break;
46    case WebHTTPBody::Element::TypeFileSystemURL:
47      output->filesystem_url = input.fileSystemURL;
48      output->file_start = input.fileStart;
49      output->file_length = input.fileLength;
50      output->file_modification_time = input.modificationTime;
51      break;
52    case WebHTTPBody::Element::TypeBlob:
53      output->blob_uuid = input.blobUUID.utf8();
54      break;
55  }
56}
57
58void AppendHTTPBodyElement(const ExplodedHttpBodyElement& element,
59                           WebHTTPBody* http_body) {
60  switch (element.type) {
61    case WebHTTPBody::Element::TypeData:
62      http_body->appendData(element.data);
63      break;
64    case WebHTTPBody::Element::TypeFile:
65      http_body->appendFileRange(
66          element.file_path,
67          element.file_start,
68          element.file_length,
69          element.file_modification_time);
70      break;
71    case WebHTTPBody::Element::TypeFileSystemURL:
72      http_body->appendFileSystemURLRange(
73          element.filesystem_url,
74          element.file_start,
75          element.file_length,
76          element.file_modification_time);
77      break;
78    case WebHTTPBody::Element::TypeBlob:
79      http_body->appendBlob(WebString::fromUTF8(element.blob_uuid));
80      break;
81  }
82}
83
84void GenerateFrameStateFromItem(const WebHistoryItem& item,
85                                ExplodedFrameState* state) {
86  state->url_string = item.urlString();
87  state->referrer = item.referrer();
88  state->referrer_policy = item.referrerPolicy();
89  state->target = item.target();
90  if (!item.stateObject().isNull())
91    state->state_object = item.stateObject().toString();
92  state->pinch_viewport_scroll_offset = item.pinchViewportScrollOffset();
93  state->scroll_offset = item.scrollOffset();
94  state->item_sequence_number = item.itemSequenceNumber();
95  state->document_sequence_number =
96      item.documentSequenceNumber();
97  state->frame_sequence_number =
98      item.frameSequenceNumber();
99  state->page_scale_factor = item.pageScaleFactor();
100  ToNullableString16Vector(item.documentState(), &state->document_state);
101
102  state->http_body.http_content_type = item.httpContentType();
103  const WebHTTPBody& http_body = item.httpBody();
104  state->http_body.is_null = http_body.isNull();
105  if (!state->http_body.is_null) {
106    state->http_body.identifier = http_body.identifier();
107    state->http_body.elements.resize(http_body.elementCount());
108    for (size_t i = 0; i < http_body.elementCount(); ++i) {
109      WebHTTPBody::Element element;
110      http_body.elementAt(i, element);
111      ToExplodedHttpBodyElement(element, &state->http_body.elements[i]);
112    }
113    state->http_body.contains_passwords = http_body.containsPasswordData();
114  }
115}
116
117void RecursivelyGenerateFrameState(HistoryEntry::HistoryNode* node,
118                                   ExplodedFrameState* state) {
119  GenerateFrameStateFromItem(node->item(), state);
120
121  std::vector<HistoryEntry::HistoryNode*>& children = node->children();
122  state->children.resize(children.size());
123  for (size_t i = 0; i < children.size(); ++i)
124    RecursivelyGenerateFrameState(children[i], &state->children[i]);
125}
126
127void RecursivelyGenerateHistoryItem(const ExplodedFrameState& state,
128                                    HistoryEntry::HistoryNode* node) {
129  WebHistoryItem item;
130  item.initialize();
131  item.setURLString(state.url_string);
132  item.setReferrer(state.referrer, state.referrer_policy);
133  item.setTarget(state.target);
134  if (!state.state_object.is_null()) {
135    item.setStateObject(
136        WebSerializedScriptValue::fromString(state.state_object));
137  }
138  item.setDocumentState(state.document_state);
139  item.setPinchViewportScrollOffset(state.pinch_viewport_scroll_offset);
140  item.setScrollOffset(state.scroll_offset);
141  item.setPageScaleFactor(state.page_scale_factor);
142
143  // These values are generated at WebHistoryItem construction time, and we
144  // only want to override those new values with old values if the old values
145  // are defined.  A value of 0 means undefined in this context.
146  if (state.item_sequence_number)
147    item.setItemSequenceNumber(state.item_sequence_number);
148  if (state.document_sequence_number)
149    item.setDocumentSequenceNumber(state.document_sequence_number);
150  if (state.frame_sequence_number)
151    item.setFrameSequenceNumber(state.frame_sequence_number);
152
153  item.setHTTPContentType(state.http_body.http_content_type);
154  if (!state.http_body.is_null) {
155    WebHTTPBody http_body;
156    http_body.initialize();
157    http_body.setIdentifier(state.http_body.identifier);
158    for (size_t i = 0; i < state.http_body.elements.size(); ++i)
159      AppendHTTPBodyElement(state.http_body.elements[i], &http_body);
160    item.setHTTPBody(http_body);
161  }
162  node->set_item(item);
163
164  for (size_t i = 0; i < state.children.size(); ++i)
165    RecursivelyGenerateHistoryItem(state.children[i], node->AddChild());
166}
167
168}  // namespace
169
170PageState HistoryEntryToPageState(HistoryEntry* entry) {
171  ExplodedPageState state;
172  ToNullableString16Vector(entry->root().getReferencedFilePaths(),
173                           &state.referenced_files);
174
175  RecursivelyGenerateFrameState(entry->root_history_node(), &state.top);
176
177  std::string encoded_data;
178  if (!EncodePageState(state, &encoded_data))
179    return PageState();
180
181  return PageState::CreateFromEncodedData(encoded_data);
182}
183
184PageState SingleHistoryItemToPageState(const WebHistoryItem& item) {
185  ExplodedPageState state;
186  ToNullableString16Vector(item.getReferencedFilePaths(),
187                           &state.referenced_files);
188  GenerateFrameStateFromItem(item, &state.top);
189
190  std::string encoded_data;
191  if (!EncodePageState(state, &encoded_data))
192    return PageState();
193
194  return PageState::CreateFromEncodedData(encoded_data);
195}
196
197scoped_ptr<HistoryEntry> PageStateToHistoryEntry(const PageState& page_state) {
198  ExplodedPageState state;
199  if (!DecodePageState(page_state.ToEncodedData(), &state))
200    return scoped_ptr<HistoryEntry>();
201
202  scoped_ptr<HistoryEntry> entry(new HistoryEntry());
203  RecursivelyGenerateHistoryItem(state.top, entry->root_history_node());
204
205  return entry.Pass();
206}
207
208}  // namespace content
209