git cl format the final third of the net/base directory

net/base/chunked_upload_data_stream_unittest.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 "net/base/chunked_upload_data_stream.h"
 
 #include <string>
 
 #include "base/memory/scoped_ptr.h"
 #include "net/base/io_buffer.h"
 #include "net/base/net_errors.h"
 #include "net/base/test_completion_callback.h"
 #include "net/base/upload_data_stream.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace net {
 
 namespace {
 
 const char kTestData[] = "0123456789";
 const size_t kTestDataSize = arraysize(kTestData) - 1;
 const size_t kTestBufferSize = 1 << 14;  // 16KB.
 
 }  // namespace
 
 // Reads data once from the upload data stream, and returns the data as string.
 // Expects the read to succeed synchronously.
 std::string ReadSync(UploadDataStream* stream, int buffer_size) {
   scoped_refptr<IOBuffer> buf = new IOBuffer(buffer_size);
-  int result = stream->Read(buf.get(),
-                            buffer_size,
-                            TestCompletionCallback().callback());
+  int result =
+      stream->Read(buf.get(), buffer_size, TestCompletionCallback().callback());
   EXPECT_GE(result, 0);
   return std::string(buf->data(), result);
 }
 
 // Check the case data is added after the first read attempt.
 TEST(ChunkedUploadDataStreamTest, AppendOnce) {
   ChunkedUploadDataStream stream(0);
 
   ASSERT_EQ(OK, stream.Init(TestCompletionCallback().callback()));
   EXPECT_FALSE(stream.IsInMemory());
@@ skipping 61 matching lines @@
   EXPECT_EQ(0u, stream.size());
   EXPECT_EQ(0u, stream.position());
   EXPECT_FALSE(stream.IsEOF());
 
   TestCompletionCallback callback;
   scoped_refptr<IOBuffer> buf = new IOBuffer(kTestBufferSize);
   for (size_t i = 0; i < kTestDataSize; ++i) {
     EXPECT_EQ(0u, stream.size());  // Content-Length is 0 for chunked data.
     EXPECT_EQ(i, stream.position());
     ASSERT_FALSE(stream.IsEOF());
-    int bytes_read = stream.Read(buf.get(),
-                                 kTestBufferSize,
-                                 callback.callback());
+    int bytes_read =
+        stream.Read(buf.get(), kTestBufferSize, callback.callback());
     ASSERT_EQ(ERR_IO_PENDING, bytes_read);
     stream.AppendData(&kTestData[i], 1, i == kTestDataSize - 1);
     ASSERT_EQ(1, callback.WaitForResult());
     EXPECT_EQ(kTestData[i], buf->data()[0]);
   }
 
   EXPECT_EQ(0u, stream.size());  // Content-Length is 0 for chunked data.
   EXPECT_EQ(kTestDataSize, stream.position());
   ASSERT_TRUE(stream.IsEOF());
 }
 
 TEST(ChunkedUploadDataStreamTest, MultipleAppendsBetweenReads) {
   ChunkedUploadDataStream stream(0);
 
   ASSERT_EQ(OK, stream.Init(TestCompletionCallback().callback()));
   EXPECT_FALSE(stream.IsInMemory());
   EXPECT_EQ(0u, stream.size());  // Content-Length is 0 for chunked data.
   EXPECT_EQ(0u, stream.position());
   EXPECT_FALSE(stream.IsEOF());
 
   scoped_refptr<IOBuffer> buf = new IOBuffer(kTestBufferSize);
   for (size_t i = 0; i < kTestDataSize; ++i) {
     EXPECT_EQ(i, stream.position());
     ASSERT_FALSE(stream.IsEOF());
     stream.AppendData(&kTestData[i], 1, i == kTestDataSize - 1);
-    int bytes_read = stream.Read(buf.get(),
-                                 kTestBufferSize,
-                                 TestCompletionCallback().callback());
+    int bytes_read = stream.Read(
+        buf.get(), kTestBufferSize, TestCompletionCallback().callback());
     ASSERT_EQ(1, bytes_read);
     EXPECT_EQ(kTestData[i], buf->data()[0]);
   }
 
   EXPECT_EQ(kTestDataSize, stream.position());
   ASSERT_TRUE(stream.IsEOF());
 }
 
 // Checks that multiple reads can be merged.
 TEST(ChunkedUploadDataStreamTest, MultipleAppendsBeforeInit) {
@@ skipping 144 matching lines @@
   EXPECT_FALSE(callback.have_result());
 
   std::string data = ReadSync(&stream, kTestBufferSize);
   EXPECT_EQ(kTestData, data);
   EXPECT_EQ(kTestDataSize, stream.position());
   ASSERT_TRUE(stream.IsEOF());
   EXPECT_FALSE(callback.have_result());
 }
 
 }  // namespace net