Deduping conversions between ResourceRequestBody/WebHTTPBody/ExplodedHttpBody.

content/common/page_state_serialization_unittest.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 <stddef.h>
 
 #include <cmath>
 
 #include "base/base64.h"
 #include "base/files/file_util.h"
@@ skipping 23 matching lines @@
 }
 
 template <typename T>
 void ExpectEquality(const std::vector<T>& a, const std::vector<T>& b) {
   EXPECT_EQ(a.size(), b.size());
   for (size_t i = 0; i < std::min(a.size(), b.size()); ++i)
     ExpectEquality(a[i], b[i]);
 }
 
 template <>
-void ExpectEquality(const ExplodedHttpBodyElement& a,
-                    const ExplodedHttpBodyElement& b) {
+void ExpectEquality(const ResourceRequestBody::Element& a,
+                    const ResourceRequestBody::Element& b) {
   EXPECT_EQ(a.type(), b.type());
-  if (a.type() == ExplodedHttpBodyElement::TYPE_BYTES &&
-      b.type() == ExplodedHttpBodyElement::TYPE_BYTES) {
+  if (a.type() == ResourceRequestBody::Element::TYPE_BYTES &&
+      b.type() == ResourceRequestBody::Element::TYPE_BYTES) {
     EXPECT_EQ(std::string(a.bytes(), a.length()),
               std::string(b.bytes(), b.length()));
   }
   EXPECT_EQ(a.path(), b.path());
   EXPECT_EQ(a.filesystem_url(), b.filesystem_url());
   EXPECT_EQ(a.offset(), b.offset());
   EXPECT_EQ(a.length(), b.length());
   EXPECT_EQ(a.expected_modification_time(), b.expected_modification_time());
   EXPECT_EQ(a.blob_uuid(), b.blob_uuid());
 }
 
 template <>
 void ExpectEquality(const ExplodedHttpBody& a, const ExplodedHttpBody& b) {
   EXPECT_EQ(a.http_content_type, b.http_content_type);
-  EXPECT_EQ(a.identifier, b.identifier);
   EXPECT_EQ(a.contains_passwords, b.contains_passwords);
-  EXPECT_EQ(a.is_null, b.is_null);
-  ExpectEquality(a.elements, b.elements);
+  if (a.request_body == nullptr || b.request_body == nullptr) {
+    EXPECT_EQ(nullptr, a.request_body);
+    EXPECT_EQ(nullptr, b.request_body);
+  } else {
+    EXPECT_EQ(a.request_body->identifier(), b.request_body->identifier());
+    ExpectEquality(*a.request_body->elements(), *b.request_body->elements());
+  }
 }
 
 template <>
 void ExpectEquality(const ExplodedFrameState& a, const ExplodedFrameState& b) {
   EXPECT_EQ(a.url_string, b.url_string);
   EXPECT_EQ(a.referrer, b.referrer);
   EXPECT_EQ(a.referrer_policy, b.referrer_policy);
   EXPECT_EQ(a.target, b.target);
   EXPECT_EQ(a.state_object, b.state_object);
   ExpectEquality(a.document_state, b.document_state);
@@ skipping 31 matching lines @@
         blink::WebHistoryScrollRestorationManual;
     frame_state->visual_viewport_scroll_offset = gfx::PointF(10, 15);
     frame_state->scroll_offset = gfx::Point(0, 100);
     frame_state->item_sequence_number = 1;
     frame_state->document_sequence_number = 2;
     frame_state->page_scale_factor = 2.0;
   }
 
   void PopulateHttpBody(ExplodedHttpBody* http_body,
                         std::vector<base::NullableString16>* referenced_files) {
-    http_body->is_null = false;
-    http_body->identifier = 12345;
+    http_body->request_body = new ResourceRequestBody();
+    http_body->request_body->set_identifier(12345);
     http_body->contains_passwords = false;
     http_body->http_content_type = NS16("text/foo");
 
-    ExplodedHttpBodyElement e1;
     std::string test_body("foo");
-    e1.SetToBytes(test_body.data(), test_body.size());
-    http_body->elements.push_back(e1);
+    http_body->request_body->AppendBytes(test_body.data(), test_body.size());
 
-    ExplodedHttpBodyElement e2;
-    e2.SetToFilePathRange(base::FilePath::FromUTF8Unsafe("file.txt"), 100, 1024,
-                          base::Time::FromDoubleT(9999.0));
-    http_body->elements.push_back(e2);
+    base::FilePath path(FILE_PATH_LITERAL("file.txt"));
+    http_body->request_body->AppendFileRange(base::FilePath(path), 100, 1024,
+                                             base::Time::FromDoubleT(9999.0));
 
     referenced_files->push_back(
-        base::NullableString16(e2.path().AsUTF16Unsafe(), false));
+        base::NullableString16(path.AsUTF16Unsafe(), false));
   }
 
   void PopulateFrameStateForBackwardsCompatTest(
       ExplodedFrameState* frame_state,
       bool is_child) {
     frame_state->url_string = NS16("http://chromium.org/");
     frame_state->referrer = NS16("http://google.com/");
     frame_state->referrer_policy = blink::WebReferrerPolicyDefault;
     if (!is_child)
       frame_state->target = NS16("target");
@@ skipping 10 matching lines @@
     frame_state->document_state.push_back(NS16("form key"));
     frame_state->document_state.push_back(NS16("1"));
     frame_state->document_state.push_back(NS16("foo"));
     frame_state->document_state.push_back(NS16("file"));
     frame_state->document_state.push_back(NS16("2"));
     frame_state->document_state.push_back(NS16("file.txt"));
     frame_state->document_state.push_back(NS16("displayName"));
 
     if (!is_child) {
       frame_state->http_body.http_content_type = NS16("foo/bar");
-      frame_state->http_body.identifier = 789;
-      frame_state->http_body.is_null = false;
+      frame_state->http_body.request_body = new ResourceRequestBody();
+      frame_state->http_body.request_body->set_identifier(789);
 
-      ExplodedHttpBodyElement e1;
       std::string test_body("first data block");
-      e1.SetToBytes(test_body.data(), test_body.size());
-      frame_state->http_body.elements.push_back(e1);
+      frame_state->http_body.request_body->AppendBytes(test_body.data(),
+                                                       test_body.size());
 
-      ExplodedHttpBodyElement e2;
-      e2.SetToFilePath(base::FilePath::FromUTF8Unsafe("file.txt"));
-      frame_state->http_body.elements.push_back(e2);
+      frame_state->http_body.request_body->AppendFileRange(
+          base::FilePath(FILE_PATH_LITERAL("file.txt")), 0,
+          std::numeric_limits<uint64_t>::max(), base::Time::FromDoubleT(0.0));
 
-      ExplodedHttpBodyElement e3;
       std::string test_body2("data the second");
-      e3.SetToBytes(test_body2.data(), test_body2.size());
-      frame_state->http_body.elements.push_back(e3);
+      frame_state->http_body.request_body->AppendBytes(test_body2.data(),
+                                                       test_body2.size());
 
       ExplodedFrameState child_state;
       PopulateFrameStateForBackwardsCompatTest(&child_state, true);
       frame_state->children.push_back(child_state);
     }
   }
 
   void PopulatePageStateForBackwardsCompatTest(ExplodedPageState* page_state) {
     page_state->referenced_files.push_back(NS16("file.txt"));
     PopulateFrameStateForBackwardsCompatTest(&page_state->top, false);
@@ skipping 244 matching lines @@
 TEST_F(PageStateSerializationTest, BackwardsCompat_v21) {
   TestBackwardsCompat(21);
 }
 
 TEST_F(PageStateSerializationTest, BackwardsCompat_v22) {
   TestBackwardsCompat(22);
 }
 
 }  // namespace
 }  // namespace content