Relanding: Deduplicating code performing WebHTTPBody::Element conversions.

content/common/page_state_serialization.cc

 // Copyright 2013 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/common/page_state_serialization.h"
 
 #include <stddef.h>
 
 #include <algorithm>
 #include <limits>
 
 #include "base/pickle.h"
+#include "base/strings/nullable_string16.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_util.h"
 #include "base/strings/utf_string_conversions.h"
 #include "build/build_config.h"
 #include "content/common/resource_request_body.h"
 #include "ui/display/display.h"
 #include "ui/display/screen.h"
 
 namespace content {
 namespace {
 
 #if defined(OS_ANDROID)
 float g_device_scale_factor_for_testing = 0.0;
 #endif
 
 //-----------------------------------------------------------------------------
 
 void AppendDataToHttpBody(ExplodedHttpBody* http_body, const char* data,
                           int data_length) {
   ExplodedHttpBodyElement element;
-  element.type = blink::WebHTTPBody::Element::TypeData;
-  element.data.assign(data, data_length);
+  element.SetToBytes(data, data_length);
   http_body->elements.push_back(element);
 }
 
 void AppendFileRangeToHttpBody(ExplodedHttpBody* http_body,
                                const base::NullableString16& file_path,
                                int file_start,
                                int file_length,
                                double file_modification_time) {
   ExplodedHttpBodyElement element;
-  element.type = blink::WebHTTPBody::Element::TypeFile;
-  element.file_path = file_path;
-  element.file_start = file_start;
-  element.file_length = file_length;
-  element.file_modification_time = file_modification_time;
+  element.SetToFilePathRange(
+      base::FilePath::FromUTF16Unsafe(file_path.string()),
+      static_cast<uint64_t>(file_start), static_cast<uint64_t>(file_length),
+      base::Time::FromDoubleT(file_modification_time));
   http_body->elements.push_back(element);
 }
 
 void AppendURLRangeToHttpBody(ExplodedHttpBody* http_body,
                               const GURL& url,
                               int file_start,
                               int file_length,
                               double file_modification_time) {
   ExplodedHttpBodyElement element;
-  element.type = blink::WebHTTPBody::Element::TypeFileSystemURL;
-  element.filesystem_url = url;
-  element.file_start = file_start;
-  element.file_length = file_length;
-  element.file_modification_time = file_modification_time;
+  element.SetToFileSystemUrlRange(
+      url, static_cast<uint64_t>(file_start),
+      static_cast<uint64_t>(file_length),
+      base::Time::FromDoubleT(file_modification_time));
   http_body->elements.push_back(element);
 }
 
 void AppendBlobToHttpBody(ExplodedHttpBody* http_body,
                           const std::string& uuid) {
   ExplodedHttpBodyElement element;
-  element.type = blink::WebHTTPBody::Element::TypeBlob;
-  element.blob_uuid = uuid;
+  element.SetToBlob(uuid);
   http_body->elements.push_back(element);
 }
 
 //----------------------------------------------------------------------------
 
 void AppendReferencedFilesFromHttpBody(
     const std::vector<ExplodedHttpBodyElement>& elements,
     std::vector<base::NullableString16>* referenced_files) {
   for (size_t i = 0; i < elements.size(); ++i) {
-    if (elements[i].type == blink::WebHTTPBody::Element::TypeFile)
-      referenced_files->push_back(elements[i].file_path);
+    if (elements[i].type() == ExplodedHttpBodyElement::TYPE_FILE)
+      referenced_files->push_back(
+          base::NullableString16(elements[i].path().AsUTF16Unsafe(), false));
   }
 }
 
 bool AppendReferencedFilesFromDocumentState(
     const std::vector<base::NullableString16>& document_state,
     std::vector<base::NullableString16>* referenced_files) {
   if (document_state.empty())
     return true;
 
   // This algorithm is adapted from Blink's core/html/FormController.cpp code.
@@ skipping 308 matching lines @@
 // Writes an ExplodedHttpBody object into a SerializeObject for serialization.
 void WriteHttpBody(const ExplodedHttpBody& http_body, SerializeObject* obj) {
   WriteBoolean(!http_body.is_null, obj);
 
   if (http_body.is_null)
     return;
 
   WriteAndValidateVectorSize(http_body.elements, obj);
   for (size_t i = 0; i < http_body.elements.size(); ++i) {
     const ExplodedHttpBodyElement& element = http_body.elements[i];
-    WriteInteger(element.type, obj);
-    if (element.type == blink::WebHTTPBody::Element::TypeData) {
-      WriteData(element.data.data(), static_cast<int>(element.data.size()),
-                obj);
-    } else if (element.type == blink::WebHTTPBody::Element::TypeFile) {
-      WriteString(element.file_path, obj);
-      WriteInteger64(element.file_start, obj);
-      WriteInteger64(element.file_length, obj);
-      WriteReal(element.file_modification_time, obj);
-    } else if (element.type ==
-               blink::WebHTTPBody::Element::TypeFileSystemURL) {
-      WriteGURL(element.filesystem_url, obj);
-      WriteInteger64(element.file_start, obj);
-      WriteInteger64(element.file_length, obj);
-      WriteReal(element.file_modification_time, obj);
-    } else {
-      DCHECK(element.type == blink::WebHTTPBody::Element::TypeBlob);
-      WriteStdString(element.blob_uuid, obj);
+    switch (element.type()) {
+      case ExplodedHttpBodyElement::TYPE_BYTES:
+        WriteInteger(blink::WebHTTPBody::Element::TypeData, obj);
+        WriteData(element.bytes(), static_cast<int>(element.length()), obj);
+        break;
+      case ExplodedHttpBodyElement::TYPE_FILE:
+        WriteInteger(blink::WebHTTPBody::Element::TypeFile, obj);
+        WriteString(
+            base::NullableString16(element.path().AsUTF16Unsafe(), false), obj);
+        WriteInteger64(static_cast<int64_t>(element.offset()), obj);
+        WriteInteger64(static_cast<int64_t>(element.length()), obj);
+        WriteReal(element.expected_modification_time().ToDoubleT(), obj);
+        break;
+      case ExplodedHttpBodyElement::TYPE_FILE_FILESYSTEM:
+        WriteInteger(blink::WebHTTPBody::Element::TypeFileSystemURL, obj);
+        WriteGURL(element.filesystem_url(), obj);
+        WriteInteger64(static_cast<int64_t>(element.offset()), obj);
+        WriteInteger64(static_cast<int64_t>(element.length()), obj);
+        WriteReal(element.expected_modification_time().ToDoubleT(), obj);
+        break;
+      case ExplodedHttpBodyElement::TYPE_BLOB:
+        WriteInteger(blink::WebHTTPBody::Element::TypeBlob, obj);
+        WriteStdString(element.blob_uuid(), obj);
+        break;
+      case ExplodedHttpBodyElement::TYPE_BYTES_DESCRIPTION:
+      case ExplodedHttpBodyElement::TYPE_DISK_CACHE_ENTRY:
+      default:
+        NOTREACHED();
+        continue;
     }
   }
   WriteInteger64(http_body.identifier, obj);
   WriteBoolean(http_body.contains_passwords, obj);
 }
 
 void ReadHttpBody(SerializeObject* obj, ExplodedHttpBody* http_body) {
   // An initial boolean indicates if we have an HTTP body.
   if (!ReadBoolean(obj))
     return;
@@ skipping 222 matching lines @@
 
   // De-dupe
   state->referenced_files.erase(
       std::unique(state->referenced_files.begin(),
                   state->referenced_files.end()),
       state->referenced_files.end());
 }
 
 }  // namespace
 
-ExplodedHttpBodyElement::ExplodedHttpBodyElement()
-    : type(blink::WebHTTPBody::Element::TypeData),
-      file_start(0),
-      file_length(-1),
-      file_modification_time(std::numeric_limits<double>::quiet_NaN()) {
-}
-
-ExplodedHttpBodyElement::ExplodedHttpBodyElement(
-    const ExplodedHttpBodyElement& other) = default;
-
-ExplodedHttpBodyElement::~ExplodedHttpBodyElement() {
-}
-
 ExplodedHttpBody::ExplodedHttpBody()
     : identifier(0),
       contains_passwords(false),
       is_null(true) {
 }
 
 ExplodedHttpBody::~ExplodedHttpBody() {
 }
 
 ExplodedFrameState::ExplodedFrameState()
@@ skipping 58 matching lines @@
   return true;
 }
 
 bool GeneratePostData(const ExplodedHttpBody& exploded,
                       ResourceRequestBody* http_body) {
   if (exploded.is_null)
     return false;
 
   http_body->set_identifier(exploded.identifier);
   for (auto element : exploded.elements)
-    http_body->AppendExplodedHTTPBodyElement(element);
+    http_body->elements_mutable()->push_back(element);
 
   return true;
 }
 
 #if defined(OS_ANDROID)
 bool DecodePageStateWithDeviceScaleFactorForTesting(
     const std::string& encoded,
     float device_scale_factor,
     ExplodedPageState* exploded) {
   g_device_scale_factor_for_testing = device_scale_factor;
   bool rv = DecodePageState(encoded, exploded);
   g_device_scale_factor_for_testing = 0.0;
   return rv;
 }
 #endif
 
 }  // namespace content