Revert of Deduplicating code performing WebHTTPBody::Element conversions.

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 <stddef.h>
 
-#include "base/strings/nullable_string16.h"
 #include "content/common/page_state_serialization.h"
 #include "content/public/common/page_state.h"
 #include "content/renderer/history_entry.h"
-#include "content/renderer/http_body_conversions.h"
-#include "third_party/WebKit/public/platform/WebData.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::WebData;
 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(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;
+    case WebHTTPBody::Element::TypeFile:
+      output->file_path = input.filePath;
+      output->file_start = input.fileStart;
+      output->file_length = input.fileLength;
+      output->file_modification_time = input.modificationTime;
+      break;
+    case WebHTTPBody::Element::TypeFileSystemURL:
+      output->filesystem_url = input.fileSystemURL;
+      output->file_start = input.fileStart;
+      output->file_length = input.fileLength;
+      output->file_modification_time = input.modificationTime;
+      break;
+    case WebHTTPBody::Element::TypeBlob:
+      output->blob_uuid = input.blobUUID.utf8();
+      break;
+  }
+}
+
+void AppendHTTPBodyElement(const ExplodedHttpBodyElement& element,
+                           WebHTTPBody* http_body) {
+  switch (element.type) {
+    case WebHTTPBody::Element::TypeData:
+      http_body->appendData(element.data);
+      break;
+    case WebHTTPBody::Element::TypeFile:
+      http_body->appendFileRange(
+          element.file_path,
+          element.file_start,
+          element.file_length,
+          element.file_modification_time);
+      break;
+    case WebHTTPBody::Element::TypeFileSystemURL:
+      http_body->appendFileSystemURLRange(
+          element.filesystem_url,
+          element.file_start,
+          element.file_length,
+          element.file_modification_time);
+      break;
+    case WebHTTPBody::Element::TypeBlob:
+      http_body->appendBlob(WebString::fromUTF8(element.blob_uuid));
+      break;
+  }
+}
+
 void GenerateFrameStateFromItem(const WebHistoryItem& item,
                                 ExplodedFrameState* state) {
   state->url_string = item.urlString();
   state->referrer = item.referrer();
   state->referrer_policy = item.referrerPolicy();
   state->target = item.target();
   if (!item.stateObject().isNull())
     state->state_object = item.stateObject().toString();
   state->scroll_restoration_type = item.scrollRestorationType();
   state->visual_viewport_scroll_offset = item.visualViewportScrollOffset();
   state->scroll_offset = item.scrollOffset();
   state->item_sequence_number = item.itemSequenceNumber();
   state->document_sequence_number =
       item.documentSequenceNumber();
   state->page_scale_factor = item.pageScaleFactor();
   ToNullableString16Vector(item.documentState(), &state->document_state);
 
   state->http_body.http_content_type = item.httpContentType();
   const WebHTTPBody& http_body = item.httpBody();
   state->http_body.is_null = http_body.isNull();
   if (!state->http_body.is_null) {
     state->http_body.identifier = http_body.identifier();
     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);
-      ConvertToHttpBodyElement(element, &state->http_body.elements[i]);
+      ToExplodedHttpBodyElement(element, &state->http_body.elements[i]);
     }
     state->http_body.contains_passwords = http_body.containsPasswordData();
   }
 }
 
 void RecursivelyGenerateFrameState(
     HistoryEntry::HistoryNode* node,
     ExplodedFrameState* state,
     std::vector<base::NullableString16>* referenced_files) {
   GenerateFrameStateFromItem(node->item(), state);
@@ skipping 32 matching lines @@
     item.setItemSequenceNumber(state.item_sequence_number);
   if (state.document_sequence_number)
     item.setDocumentSequenceNumber(state.document_sequence_number);
 
   item.setHTTPContentType(state.http_body.http_content_type);
   if (!state.http_body.is_null) {
     WebHTTPBody http_body;
     http_body.initialize();
     http_body.setIdentifier(state.http_body.identifier);
     for (size_t i = 0; i < state.http_body.elements.size(); ++i)
-      AppendHttpBodyElement(state.http_body.elements[i], &http_body);
+      AppendHTTPBodyElement(state.http_body.elements[i], &http_body);
     item.setHTTPBody(http_body);
   }
   node->set_item(item);
 
   for (size_t i = 0; i < state.children.size(); ++i)
     RecursivelyGenerateHistoryItem(state.children[i], node->AddChild());
 }
 
 }  // namespace
 
@@ skipping 28 matching lines @@
   if (!DecodePageState(page_state.ToEncodedData(), &state))
     return std::unique_ptr<HistoryEntry>();
 
   std::unique_ptr<HistoryEntry> entry(new HistoryEntry());
   RecursivelyGenerateHistoryItem(state.top, entry->root_history_node());
 
   return entry;
 }
 
 }  // namespace content