Stop sending serialized SSLStatus to the renderer.

content/browser/loader/mojo_async_resource_handler_unittest.cc

 // Copyright 2016 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/browser/loader/mojo_async_resource_handler.h"
 
 #include <string.h>
 
 #include <utility>
 
@@ skipping 529 matching lines @@
   io_buffer->data()[0] = 'A';
 }
 
 TEST_F(MojoAsyncResourceHandlerTest, OnResponseCompleted) {
   bool defer = false;
   ASSERT_TRUE(CallOnWillStartAndOnResponseStarted());
 
   ResourceRequestInfoImpl::ForRequest(request_.get())
       ->set_was_ignored_by_handler(false);
   net::URLRequestStatus status(net::URLRequestStatus::SUCCESS, net::OK);
-  std::string security_info = "info0";
 
   base::TimeTicks now1 = base::TimeTicks::Now();
-  handler_->OnResponseCompleted(status, security_info, &defer);
+  handler_->OnResponseCompleted(status, &defer);
   base::TimeTicks now2 = base::TimeTicks::Now();
   EXPECT_FALSE(defer);
 
   url_loader_client_.RunUntilComplete();
   EXPECT_TRUE(url_loader_client_.has_received_completion());
   EXPECT_EQ(net::OK, url_loader_client_.completion_status().error_code);
   EXPECT_FALSE(url_loader_client_.completion_status().was_ignored_by_handler);
-  EXPECT_EQ("info0", url_loader_client_.completion_status().security_info);
   EXPECT_LE(now1, url_loader_client_.completion_status().completion_time);
   EXPECT_LE(url_loader_client_.completion_status().completion_time, now2);
   EXPECT_EQ(request_->GetTotalReceivedBytes(),
             url_loader_client_.completion_status().encoded_data_length);
 }
 
 // This test case sets different status values from OnResponseCompleted.
 TEST_F(MojoAsyncResourceHandlerTest, OnResponseCompleted2) {
   rdh_.SetDelegate(nullptr);
   bool defer = false;
   // Don't use CallOnWillStartAndOnResponseStarted as this test case manually
   // sets the null delegate.
   ASSERT_TRUE(CallOnWillStart());
   scoped_refptr<ResourceResponse> response = new ResourceResponse();
   ASSERT_TRUE(handler_->OnResponseStarted(response.get(), &defer));
   ASSERT_FALSE(defer);
   ASSERT_FALSE(url_loader_client_.has_received_response());
   url_loader_client_.RunUntilResponseReceived();
 
   ResourceRequestInfoImpl::ForRequest(request_.get())
       ->set_was_ignored_by_handler(true);
   net::URLRequestStatus status(net::URLRequestStatus::CANCELED,
                                net::ERR_ABORTED);
-  std::string security_info = "info1";
 
   base::TimeTicks now1 = base::TimeTicks::Now();
-  handler_->OnResponseCompleted(status, security_info, &defer);
+  handler_->OnResponseCompleted(status, &defer);
   base::TimeTicks now2 = base::TimeTicks::Now();
   EXPECT_FALSE(defer);
 
   url_loader_client_.RunUntilComplete();
   EXPECT_TRUE(url_loader_client_.has_received_completion());
   EXPECT_EQ(net::ERR_ABORTED,
             url_loader_client_.completion_status().error_code);
   EXPECT_TRUE(url_loader_client_.completion_status().was_ignored_by_handler);
-  EXPECT_EQ("info1", url_loader_client_.completion_status().security_info);
   EXPECT_LE(now1, url_loader_client_.completion_status().completion_time);
   EXPECT_LE(url_loader_client_.completion_status().completion_time, now2);
   EXPECT_EQ(request_->GetTotalReceivedBytes(),
             url_loader_client_.completion_status().encoded_data_length);
 }
 
 TEST_F(MojoAsyncResourceHandlerTest, OnResponseCompletedWithCanceledTimedOut) {
   net::URLRequestStatus status(net::URLRequestStatus::CANCELED,
                                net::ERR_TIMED_OUT);
   bool defer = false;
 
   ASSERT_TRUE(CallOnWillStartAndOnResponseStarted());
-  handler_->OnResponseCompleted(status, "security_info", &defer);
+  handler_->OnResponseCompleted(status, &defer);
   EXPECT_FALSE(defer);
 
   url_loader_client_.RunUntilComplete();
   EXPECT_TRUE(url_loader_client_.has_received_completion());
   EXPECT_EQ(net::ERR_TIMED_OUT,
             url_loader_client_.completion_status().error_code);
 }
 
 TEST_F(MojoAsyncResourceHandlerTest, OnResponseCompletedWithFailedTimedOut) {
   net::URLRequestStatus status(net::URLRequestStatus::FAILED,
                                net::ERR_TIMED_OUT);
   bool defer = false;
 
   ASSERT_TRUE(CallOnWillStartAndOnResponseStarted());
-  handler_->OnResponseCompleted(status, "security_info", &defer);
+  handler_->OnResponseCompleted(status, &defer);
   EXPECT_FALSE(defer);
 
   url_loader_client_.RunUntilComplete();
   EXPECT_TRUE(url_loader_client_.has_received_completion());
   EXPECT_EQ(net::ERR_TIMED_OUT,
             url_loader_client_.completion_status().error_code);
 }
 
 TEST_F(MojoAsyncResourceHandlerTest, ResponseCompletionShouldCloseDataPipe) {
   ASSERT_TRUE(CallOnWillStartAndOnResponseStarted());
 
   scoped_refptr<net::IOBuffer> io_buffer;
   int io_buffer_size = 0;
   bool defer = false;
   ASSERT_TRUE(handler_->OnWillRead(&io_buffer, &io_buffer_size, -1));
   url_loader_client_.RunUntilResponseBodyArrived();
   ASSERT_TRUE(url_loader_client_.response_body().is_valid());
   ASSERT_TRUE(handler_->OnReadCompleted(0, &defer));
   EXPECT_FALSE(defer);
 
   net::URLRequestStatus status(net::URLRequestStatus::SUCCESS, net::OK);
-  handler_->OnResponseCompleted(status, "security_info", &defer);
+  handler_->OnResponseCompleted(status, &defer);
   EXPECT_FALSE(defer);
 
   url_loader_client_.RunUntilComplete();
   EXPECT_TRUE(url_loader_client_.has_received_completion());
   EXPECT_EQ(net::OK, url_loader_client_.completion_status().error_code);
 
   // This is needed because |*io_buffer| may keep the data producer alive.
   io_buffer = nullptr;
 
   while (true) {
@@ skipping 17 matching lines @@
   url_loader_client_.RunUntilResponseBodyArrived();
   ASSERT_TRUE(url_loader_client_.response_body().is_valid());
   ASSERT_GT(io_buffer_size, 0);
   memset(io_buffer->data(), 'a', io_buffer_size);
   bool defer = false;
   ASSERT_TRUE(handler_->OnReadCompleted(io_buffer_size, &defer));
   // We don't care |defer|'s value here.
 
   defer = false;
   net::URLRequestStatus status(net::URLRequestStatus::FAILED, net::ERR_FAILED);
-  handler_->OnResponseCompleted(status, "security_info", &defer);
+  handler_->OnResponseCompleted(status, &defer);
   EXPECT_FALSE(defer);
 
   url_loader_client_.RunUntilComplete();
   EXPECT_TRUE(url_loader_client_.has_received_completion());
   EXPECT_EQ(net::ERR_FAILED, url_loader_client_.completion_status().error_code);
 
   // This is needed because |*io_buffer| may keep the data producer alive.
   io_buffer = nullptr;
 
   std::string actual;
@@ skipping 19 matching lines @@
 TEST_F(MojoAsyncResourceHandlerTest, ResponseErrorDuringBodyTransmission2) {
   ASSERT_TRUE(CallOnWillStartAndOnResponseStarted());
 
   scoped_refptr<net::IOBuffer> io_buffer;
   int io_buffer_size = 0;
   ASSERT_TRUE(handler_->OnWillRead(&io_buffer, &io_buffer_size, -1));
   url_loader_client_.RunUntilResponseBodyArrived();
   ASSERT_TRUE(url_loader_client_.response_body().is_valid());
   bool defer = false;
   net::URLRequestStatus status(net::URLRequestStatus::FAILED, net::ERR_FAILED);
-  handler_->OnResponseCompleted(status, "security_info", &defer);
+  handler_->OnResponseCompleted(status, &defer);
   EXPECT_FALSE(defer);
 
   url_loader_client_.RunUntilComplete();
   EXPECT_TRUE(url_loader_client_.has_received_completion());
   EXPECT_EQ(net::ERR_FAILED, url_loader_client_.completion_status().error_code);
 
   // This is needed because |*io_buffer| may keep the data producer alive.
   io_buffer = nullptr;
 
   while (true) {
@@ skipping 259 matching lines @@
     ASSERT_TRUE(handler_->OnWillRead(&io_buffer, &io_buffer_size, -1));
     ASSERT_TRUE(handler_->OnReadCompleted(io_buffer_size, &defer));
   }
 
   url_loader_client_.RunUntilResponseBodyArrived();
   ASSERT_TRUE(url_loader_client_.response_body().is_valid());
 
   defer = false;
   net::URLRequestStatus status(net::URLRequestStatus::CANCELED,
                                net::ERR_ABORTED);
-  handler_->OnResponseCompleted(status, "security_info", &defer);
+  handler_->OnResponseCompleted(status, &defer);
 
   ASSERT_FALSE(url_loader_client_.has_received_completion());
   url_loader_client_.RunUntilComplete();
   EXPECT_EQ(net::ERR_ABORTED,
             url_loader_client_.completion_status().error_code);
 
   while (true) {
     char buffer[16];
     uint32_t read_size = sizeof(buffer);
     MojoResult result =
@@ skipping 32 matching lines @@
   ASSERT_GT(io_buffer_size, 0);
   io_buffer->data()[0] = 'A';
 
   ASSERT_FALSE(url_loader_client_.response_body().is_valid());
   url_loader_client_.RunUntilResponseBodyArrived();
   ASSERT_TRUE(url_loader_client_.response_body().is_valid());
 
   ASSERT_TRUE(handler_->OnReadCompleted(1, &defer));
   ASSERT_FALSE(defer);
   net::URLRequestStatus status(net::URLRequestStatus::SUCCESS, net::OK);
-  handler_->OnResponseCompleted(status, "security info", &defer);
+  handler_->OnResponseCompleted(status, &defer);
   ASSERT_FALSE(defer);
 
   ASSERT_FALSE(url_loader_client_.has_received_completion());
   url_loader_client_.RunUntilComplete();
   EXPECT_EQ(net::OK, url_loader_client_.completion_status().error_code);
 
   // This is needed because |*io_buffer| may keep the data producer alive.
   io_buffer = nullptr;
 
   std::string body;
@@ skipping 39 matching lines @@
   scoped_refptr<ResourceResponse> response = new ResourceResponse();
   ASSERT_TRUE(handler_->OnResponseStarted(response.get(), &defer));
   ASSERT_FALSE(defer);
 
   ASSERT_FALSE(url_loader_client_.has_received_response());
   url_loader_client_.RunUntilResponseReceived();
 
   ASSERT_TRUE(handler_->OnReadCompleted(1, &defer));
   ASSERT_FALSE(defer);
   net::URLRequestStatus status(net::URLRequestStatus::SUCCESS, net::OK);
-  handler_->OnResponseCompleted(status, "security info", &defer);
+  handler_->OnResponseCompleted(status, &defer);
   ASSERT_FALSE(defer);
 
   ASSERT_FALSE(url_loader_client_.has_received_completion());
   url_loader_client_.RunUntilComplete();
   EXPECT_EQ(net::OK, url_loader_client_.completion_status().error_code);
 
   // This is needed because |*io_buffer| may keep the data producer alive.
   io_buffer = nullptr;
 
   std::string body;
@@ skipping 13 matching lines @@
     }
   }
   EXPECT_EQ("B", body);
 }
 
 INSTANTIATE_TEST_CASE_P(MojoAsyncResourceHandlerWithAllocationSizeTest,
                         MojoAsyncResourceHandlerWithAllocationSizeTest,
                         ::testing::Values(8, 32 * 2014));
 }  // namespace
 }  // namespace content