Merge ResourceRequestBodyImpl and ResourceRequestBody.

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_impl.h"
+#include "content/public/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 AppendDataToRequestBody(
-    const scoped_refptr<ResourceRequestBodyImpl>& request_body,
+    const scoped_refptr<ResourceRequestBody>& request_body,
     const char* data,
     int data_length) {
   request_body->AppendBytes(data, data_length);
 }
 
 void AppendFileRangeToRequestBody(
-    const scoped_refptr<ResourceRequestBodyImpl>& request_body,
+    const scoped_refptr<ResourceRequestBody>& request_body,
     const base::NullableString16& file_path,
     int file_start,
     int file_length,
     double file_modification_time) {
   request_body->AppendFileRange(
       base::FilePath::FromUTF16Unsafe(file_path.string()),
       static_cast<uint64_t>(file_start), static_cast<uint64_t>(file_length),
       base::Time::FromDoubleT(file_modification_time));
 }
 
 void AppendURLRangeToRequestBody(
-    const scoped_refptr<ResourceRequestBodyImpl>& request_body,
+    const scoped_refptr<ResourceRequestBody>& request_body,
     const GURL& url,
     int file_start,
     int file_length,
     double file_modification_time) {
   request_body->AppendFileSystemFileRange(
       url, static_cast<uint64_t>(file_start),
       static_cast<uint64_t>(file_length),
       base::Time::FromDoubleT(file_modification_time));
 }
 
 void AppendBlobToRequestBody(
-    const scoped_refptr<ResourceRequestBodyImpl>& request_body,
+    const scoped_refptr<ResourceRequestBody>& request_body,
     const std::string& uuid) {
   request_body->AppendBlob(uuid);
 }
 
 //----------------------------------------------------------------------------
 
 void AppendReferencedFilesFromHttpBody(
-    const std::vector<ResourceRequestBodyImpl::Element>& elements,
+    const std::vector<ResourceRequestBody::Element>& elements,
     std::vector<base::NullableString16>* referenced_files) {
   for (size_t i = 0; i < elements.size(); ++i) {
-    if (elements[i].type() == ResourceRequestBodyImpl::Element::TYPE_FILE)
+    if (elements[i].type() == ResourceRequestBody::Element::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;
@@ skipping 301 matching lines @@
 void ReadStringVector(SerializeObject* obj,
                       std::vector<base::NullableString16>* result) {
   size_t num_elements =
       ReadAndValidateVectorSize(obj, sizeof(base::NullableString16));
 
   result->resize(num_elements);
   for (size_t i = 0; i < num_elements; ++i)
     (*result)[i] = ReadString(obj);
 }
 
-void WriteResourceRequestBody(const ResourceRequestBodyImpl& request_body,
+void WriteResourceRequestBody(const ResourceRequestBody& request_body,
                               SerializeObject* obj) {
   WriteAndValidateVectorSize(*request_body.elements(), obj);
   for (const auto& element : *request_body.elements()) {
     switch (element.type()) {
-      case ResourceRequestBodyImpl::Element::TYPE_BYTES:
+      case ResourceRequestBody::Element::TYPE_BYTES:
         WriteInteger(blink::WebHTTPBody::Element::kTypeData, obj);
         WriteData(element.bytes(), static_cast<int>(element.length()), obj);
         break;
-      case ResourceRequestBodyImpl::Element::TYPE_FILE:
+      case ResourceRequestBody::Element::TYPE_FILE:
         WriteInteger(blink::WebHTTPBody::Element::kTypeFile, 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 ResourceRequestBodyImpl::Element::TYPE_FILE_FILESYSTEM:
+      case ResourceRequestBody::Element::TYPE_FILE_FILESYSTEM:
         WriteInteger(blink::WebHTTPBody::Element::kTypeFileSystemURL, 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 ResourceRequestBodyImpl::Element::TYPE_BLOB:
+      case ResourceRequestBody::Element::TYPE_BLOB:
         WriteInteger(blink::WebHTTPBody::Element::kTypeBlob, obj);
         WriteStdString(element.blob_uuid(), obj);
         break;
-      case ResourceRequestBodyImpl::Element::TYPE_BYTES_DESCRIPTION:
-      case ResourceRequestBodyImpl::Element::TYPE_DISK_CACHE_ENTRY:
+      case ResourceRequestBody::Element::TYPE_BYTES_DESCRIPTION:
+      case ResourceRequestBody::Element::TYPE_DISK_CACHE_ENTRY:
       default:
         NOTREACHED();
         continue;
     }
   }
   WriteInteger64(request_body.identifier(), obj);
 }
 
 void ReadResourceRequestBody(
     SerializeObject* obj,
-    const scoped_refptr<ResourceRequestBodyImpl>& request_body) {
+    const scoped_refptr<ResourceRequestBody>& request_body) {
   int num_elements = ReadInteger(obj);
   for (int i = 0; i < num_elements; ++i) {
     int type = ReadInteger(obj);
     if (type == blink::WebHTTPBody::Element::kTypeData) {
       const void* data;
       int length = -1;
       ReadData(obj, &data, &length);
       if (length >= 0) {
         AppendDataToRequestBody(request_body, static_cast<const char*>(data),
                                 length);
@@ skipping 33 matching lines @@
 
   WriteResourceRequestBody(*http_body.request_body, 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;
 
-  http_body->request_body = new ResourceRequestBodyImpl();
+  http_body->request_body = new ResourceRequestBody();
   ReadResourceRequestBody(obj, http_body->request_body);
 
   if (obj->version >= 12)
     http_body->contains_passwords = ReadBoolean(obj);
 }
 
 // Writes the ExplodedFrameState data into the SerializeObject object for
 // serialization.
 void WriteFrameState(
     const ExplodedFrameState& state, SerializeObject* obj, bool is_top) {
@@ skipping 273 matching lines @@
 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;
 }
 
-scoped_refptr<ResourceRequestBodyImpl> DecodeResourceRequestBody(
-    const char* data,
-    size_t size) {
-  scoped_refptr<ResourceRequestBodyImpl> result = new ResourceRequestBodyImpl();
+scoped_refptr<ResourceRequestBody> DecodeResourceRequestBody(const char* data,
+                                                             size_t size) {
+  scoped_refptr<ResourceRequestBody> result = new ResourceRequestBody();
   SerializeObject obj(data, static_cast<int>(size));
   ReadResourceRequestBody(&obj, result);
   // Please see the EncodeResourceRequestBody() function below for information
   // about why the contains_sensitive_info() field is being explicitly
   // deserialized.
   result->set_contains_sensitive_info(ReadBoolean(&obj));
   return obj.parse_error ? nullptr : result;
 }
 
 std::string EncodeResourceRequestBody(
-    const ResourceRequestBodyImpl& resource_request_body) {
+    const ResourceRequestBody& resource_request_body) {
   SerializeObject obj;
   obj.version = kCurrentVersion;
   WriteResourceRequestBody(resource_request_body, &obj);
   // EncodeResourceRequestBody() is different from WriteResourceRequestBody()
   // because it covers additional data (e.g.|contains_sensitive_info|) which
   // is marshaled between native code and java. WriteResourceRequestBody()
   // serializes data which needs to be saved out to disk.
   WriteBoolean(resource_request_body.contains_sensitive_info(), &obj);
   return obj.GetAsString();
 }
 
 #endif
 
 }  // namespace content