src/content/public/renderer/history_item_serialization.cc

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