Track referenced files of subframes in PageState.

content/renderer/history_serialization.cc

 // Copyright 2014 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "content/renderer/history_serialization.h"
 
 #include "content/common/page_state_serialization.h"
 #include "content/public/common/page_state.h"
 #include "content/renderer/history_entry.h"
 #include "third_party/WebKit/public/platform/WebFloatPoint.h"
 #include "third_party/WebKit/public/platform/WebHTTPBody.h"
 #include "third_party/WebKit/public/platform/WebPoint.h"
 #include "third_party/WebKit/public/platform/WebString.h"
 #include "third_party/WebKit/public/platform/WebVector.h"
 #include "third_party/WebKit/public/web/WebHistoryItem.h"
 #include "third_party/WebKit/public/web/WebSerializedScriptValue.h"
 
 using blink::WebHTTPBody;
 using blink::WebHistoryItem;
 using blink::WebSerializedScriptValue;
 using blink::WebString;
 using blink::WebVector;
 
 namespace content {
 namespace {
 
 void ToNullableString16Vector(const WebVector<WebString>& input,
                               std::vector<base::NullableString16>* output) {
-  output->reserve(input.size());
+  output->reserve(output->size() + input.size());
   for (size_t i = 0; i < input.size(); ++i)
     output->push_back(input[i]);
 }
 
 void ToExplodedHttpBodyElement(const WebHTTPBody::Element& input,
                                ExplodedHttpBodyElement* output) {
   switch (input.type) {
     case WebHTTPBody::Element::TypeData:
       output->data.assign(input.data.data(), input.data.size());
       break;
@@ skipping 67 matching lines @@
     state->http_body.elements.resize(http_body.elementCount());
     for (size_t i = 0; i < http_body.elementCount(); ++i) {
       WebHTTPBody::Element element;
       http_body.elementAt(i, element);
       ToExplodedHttpBodyElement(element, &state->http_body.elements[i]);
     }
     state->http_body.contains_passwords = http_body.containsPasswordData();
   }
 }
 
-void RecursivelyGenerateFrameState(HistoryEntry::HistoryNode* node,
-                                   ExplodedFrameState* state) {
+void RecursivelyGenerateFrameState(
+    HistoryEntry::HistoryNode* node,
+    ExplodedFrameState* state,
+    std::vector<base::NullableString16>* referenced_files) {
   GenerateFrameStateFromItem(node->item(), state);
+  ToNullableString16Vector(node->item().getReferencedFilePaths(),
+                           referenced_files);
 
   std::vector<HistoryEntry::HistoryNode*>& children = node->children();
   state->children.resize(children.size());
-  for (size_t i = 0; i < children.size(); ++i)
-    RecursivelyGenerateFrameState(children[i], &state->children[i]);
+  for (size_t i = 0; i < children.size(); ++i) {
+    RecursivelyGenerateFrameState(children[i], &state->children[i],
+                                  referenced_files);
+  }
 }
 
 void RecursivelyGenerateHistoryItem(const ExplodedFrameState& state,
                                     HistoryEntry::HistoryNode* node) {
   WebHistoryItem item;
   item.initialize();
   item.setURLString(state.url_string);
   item.setReferrer(state.referrer, state.referrer_policy);
   item.setTarget(state.target);
   if (!state.state_object.is_null()) {
@@ skipping 27 matching lines @@
   node->set_item(item);
 
   for (size_t i = 0; i < state.children.size(); ++i)
     RecursivelyGenerateHistoryItem(state.children[i], node->AddChild());
 }
 
 }  // namespace
 
 PageState HistoryEntryToPageState(HistoryEntry* entry) {
   ExplodedPageState state;
-  ToNullableString16Vector(entry->root().getReferencedFilePaths(),
-                           &state.referenced_files);
-
-  RecursivelyGenerateFrameState(entry->root_history_node(), &state.top);
+  RecursivelyGenerateFrameState(entry->root_history_node(), &state.top,
+                                &state.referenced_files);
 
   std::string encoded_data;
   if (!EncodePageState(state, &encoded_data))
     return PageState();
 
   return PageState::CreateFromEncodedData(encoded_data);
 }
 
 PageState SingleHistoryItemToPageState(const WebHistoryItem& item) {
   ExplodedPageState state;
@@ skipping 13 matching lines @@
   if (!DecodePageState(page_state.ToEncodedData(), &state))
     return scoped_ptr<HistoryEntry>();
 
   scoped_ptr<HistoryEntry> entry(new HistoryEntry());
   RecursivelyGenerateHistoryItem(state.top, entry->root_history_node());
 
   return entry.Pass();
 }
 
 }  // namespace content