Clang format slam.

net/base/upload_data_stream_unittest.cc

 // Copyright (c) 2012 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/upload_data_stream.h"
 
 #include <algorithm>
 #include <vector>
 
 #include "base/basictypes.h"
@@ skipping 52 matching lines @@
         init_result_(OK),
         read_result_(OK) {}
 
   virtual ~MockUploadElementReader() {}
 
   // UploadElementReader overrides.
   MOCK_METHOD1(Init, int(const CompletionCallback& callback));
   virtual uint64 GetContentLength() const OVERRIDE { return content_length_; }
   virtual uint64 BytesRemaining() const OVERRIDE { return bytes_remaining_; }
   virtual bool IsInMemory() const OVERRIDE { return is_in_memory_; }
-  MOCK_METHOD3(Read, int(IOBuffer* buf,
-                         int buf_length,
-                         const CompletionCallback& callback));
+  MOCK_METHOD3(Read,
+               int(IOBuffer* buf,
+                   int buf_length,
+                   const CompletionCallback& callback));
 
   // Sets expectation to return the specified result from Init() asynchronously.
   void SetAsyncInitExpectation(int result) {
     init_result_ = result;
     EXPECT_CALL(*this, Init(_))
         .WillOnce(DoAll(Invoke(this, &MockUploadElementReader::OnInit),
                         Return(ERR_IO_PENDING)));
   }
 
   // Sets expectation to return the specified result from Read().
@@ skipping 58 matching lines @@
 TEST_F(UploadDataStreamTest, EmptyUploadData) {
   UploadDataStream stream(element_readers_.Pass(), 0);
   ASSERT_EQ(OK, stream.Init(CompletionCallback()));
   EXPECT_TRUE(stream.IsInMemory());
   EXPECT_EQ(0U, stream.size());
   EXPECT_EQ(0U, stream.position());
   EXPECT_TRUE(stream.IsEOF());
 }
 
 TEST_F(UploadDataStreamTest, ConsumeAllBytes) {
-  element_readers_.push_back(new UploadBytesElementReader(
-      kTestData, kTestDataSize));
+  element_readers_.push_back(
+      new UploadBytesElementReader(kTestData, kTestDataSize));
   UploadDataStream stream(element_readers_.Pass(), 0);
   ASSERT_EQ(OK, stream.Init(CompletionCallback()));
   EXPECT_TRUE(stream.IsInMemory());
   EXPECT_EQ(kTestDataSize, stream.size());
   EXPECT_EQ(0U, stream.position());
   EXPECT_FALSE(stream.IsEOF());
   scoped_refptr<IOBuffer> buf = new IOBuffer(kTestBufferSize);
   while (!stream.IsEOF()) {
     int bytes_read =
         stream.Read(buf.get(), kTestBufferSize, CompletionCallback());
     ASSERT_LE(0, bytes_read);  // Not an error.
   }
   EXPECT_EQ(kTestDataSize, stream.position());
   ASSERT_TRUE(stream.IsEOF());
 }
 
 TEST_F(UploadDataStreamTest, File) {
   base::FilePath temp_file_path;
-  ASSERT_TRUE(base::CreateTemporaryFileInDir(temp_dir_.path(),
-                                             &temp_file_path));
+  ASSERT_TRUE(
+      base::CreateTemporaryFileInDir(temp_dir_.path(), &temp_file_path));
   ASSERT_EQ(static_cast<int>(kTestDataSize),
             base::WriteFile(temp_file_path, kTestData, kTestDataSize));
 
   element_readers_.push_back(
       new UploadFileElementReader(base::MessageLoopProxy::current().get(),
                                   temp_file_path,
                                   0,
                                   kuint64max,
                                   base::Time()));
 
@@ skipping 12 matching lines @@
         ERR_IO_PENDING,
         stream.Read(buf.get(), kTestBufferSize, read_callback.callback()));
     ASSERT_LE(0, read_callback.WaitForResult());  // Not an error.
   }
   EXPECT_EQ(kTestDataSize, stream.position());
   ASSERT_TRUE(stream.IsEOF());
 }
 
 TEST_F(UploadDataStreamTest, FileSmallerThanLength) {
   base::FilePath temp_file_path;
-  ASSERT_TRUE(base::CreateTemporaryFileInDir(temp_dir_.path(),
-                                             &temp_file_path));
+  ASSERT_TRUE(
+      base::CreateTemporaryFileInDir(temp_dir_.path(), &temp_file_path));
   ASSERT_EQ(static_cast<int>(kTestDataSize),
             base::WriteFile(temp_file_path, kTestData, kTestDataSize));
-  const uint64 kFakeSize = kTestDataSize*2;
+  const uint64 kFakeSize = kTestDataSize * 2;
 
   UploadFileElementReader::ScopedOverridingContentLengthForTests
       overriding_content_length(kFakeSize);
 
   element_readers_.push_back(
       new UploadFileElementReader(base::MessageLoopProxy::current().get(),
                                   temp_file_path,
                                   0,
                                   kuint64max,
                                   base::Time()));
@@ skipping 26 matching lines @@
 
 TEST_F(UploadDataStreamTest, ReadErrorSync) {
   // This element cannot be read.
   MockUploadElementReader* reader =
       new MockUploadElementReader(kTestDataSize, true);
   EXPECT_CALL(*reader, Init(_)).WillOnce(Return(OK));
   reader->SetReadExpectation(ERR_FAILED);
   element_readers_.push_back(reader);
 
   // This element is ignored because of the error from the previous reader.
-  element_readers_.push_back(new UploadBytesElementReader(
-      kTestData, kTestDataSize));
+  element_readers_.push_back(
+      new UploadBytesElementReader(kTestData, kTestDataSize));
 
   UploadDataStream stream(element_readers_.Pass(), 0);
 
   // Run Init().
   ASSERT_EQ(OK, stream.Init(CompletionCallback()));
-  EXPECT_EQ(kTestDataSize*2, stream.size());
+  EXPECT_EQ(kTestDataSize * 2, stream.size());
   EXPECT_EQ(0U, stream.position());
   EXPECT_FALSE(stream.IsEOF());
 
   // Prepare a buffer filled with non-zero data.
   scoped_refptr<IOBuffer> buf = new IOBuffer(kTestBufferSize);
   std::fill_n(buf->data(), kTestBufferSize, -1);
 
   // Read() results in success even when the reader returns error.
   EXPECT_EQ(static_cast<int>(kTestDataSize * 2),
             stream.Read(buf.get(), kTestBufferSize, CompletionCallback()));
   EXPECT_EQ(kTestDataSize * 2, stream.position());
   EXPECT_TRUE(stream.IsEOF());
 
   // The buffer is filled with zero.
-  EXPECT_EQ(static_cast<int>(kTestDataSize*2),
+  EXPECT_EQ(static_cast<int>(kTestDataSize * 2),
             std::count(buf->data(), buf->data() + kTestBufferSize, 0));
 }
 
 TEST_F(UploadDataStreamTest, ReadErrorAsync) {
   // This element cannot be read.
   MockUploadElementReader* reader =
       new MockUploadElementReader(kTestDataSize, false);
   reader->SetAsyncInitExpectation(OK);
   reader->SetReadExpectation(ERR_FAILED);
   element_readers_.push_back(reader);
 
   // This element is ignored because of the error from the previous reader.
-  element_readers_.push_back(new UploadBytesElementReader(
-      kTestData, kTestDataSize));
+  element_readers_.push_back(
+      new UploadBytesElementReader(kTestData, kTestDataSize));
 
   UploadDataStream stream(element_readers_.Pass(), 0);
 
   // Run Init().
   TestCompletionCallback init_callback;
   ASSERT_EQ(ERR_IO_PENDING, stream.Init(init_callback.callback()));
   EXPECT_EQ(OK, init_callback.WaitForResult());
-  EXPECT_EQ(kTestDataSize*2, stream.size());
+  EXPECT_EQ(kTestDataSize * 2, stream.size());
   EXPECT_EQ(0U, stream.position());
   EXPECT_FALSE(stream.IsEOF());
 
   // Prepare a buffer filled with non-zero data.
   scoped_refptr<IOBuffer> buf = new IOBuffer(kTestBufferSize);
   std::fill_n(buf->data(), kTestBufferSize, -1);
 
   // Read() results in success even when the reader returns error.
   TestCompletionCallback read_callback;
   ASSERT_EQ(ERR_IO_PENDING,
             stream.Read(buf.get(), kTestBufferSize, read_callback.callback()));
   EXPECT_EQ(static_cast<int>(kTestDataSize * 2), read_callback.WaitForResult());
-  EXPECT_EQ(kTestDataSize*2, stream.position());
+  EXPECT_EQ(kTestDataSize * 2, stream.position());
   EXPECT_TRUE(stream.IsEOF());
 
   // The buffer is filled with zero.
-  EXPECT_EQ(static_cast<int>(kTestDataSize*2),
+  EXPECT_EQ(static_cast<int>(kTestDataSize * 2),
             std::count(buf->data(), buf->data() + kTestBufferSize, 0));
 }
 
 TEST_F(UploadDataStreamTest, FileAndBytes) {
   base::FilePath temp_file_path;
-  ASSERT_TRUE(base::CreateTemporaryFileInDir(temp_dir_.path(),
-                                             &temp_file_path));
+  ASSERT_TRUE(
+      base::CreateTemporaryFileInDir(temp_dir_.path(), &temp_file_path));
   ASSERT_EQ(static_cast<int>(kTestDataSize),
             base::WriteFile(temp_file_path, kTestData, kTestDataSize));
 
   const uint64 kFileRangeOffset = 1;
   const uint64 kFileRangeLength = 4;
   element_readers_.push_back(
       new UploadFileElementReader(base::MessageLoopProxy::current().get(),
                                   temp_file_path,
                                   kFileRangeOffset,
                                   kFileRangeLength,
                                   base::Time()));
 
-  element_readers_.push_back(new UploadBytesElementReader(
-      kTestData, kTestDataSize));
+  element_readers_.push_back(
+      new UploadBytesElementReader(kTestData, kTestDataSize));
 
   const uint64 kStreamSize = kTestDataSize + kFileRangeLength;
   TestCompletionCallback init_callback;
   UploadDataStream stream(element_readers_.Pass(), 0);
   ASSERT_EQ(ERR_IO_PENDING, stream.Init(init_callback.callback()));
   ASSERT_EQ(OK, init_callback.WaitForResult());
   EXPECT_FALSE(stream.IsInMemory());
   EXPECT_EQ(kStreamSize, stream.size());
   EXPECT_EQ(0U, stream.position());
   EXPECT_FALSE(stream.IsEOF());
   scoped_refptr<IOBuffer> buf = new IOBuffer(kTestBufferSize);
   while (!stream.IsEOF()) {
     TestCompletionCallback read_callback;
     const int result =
         stream.Read(buf.get(), kTestBufferSize, read_callback.callback());
     const int bytes_read =
         result != ERR_IO_PENDING ? result : read_callback.WaitForResult();
     ASSERT_LE(0, bytes_read);  // Not an error.
   }
   EXPECT_EQ(kStreamSize, stream.position());
   ASSERT_TRUE(stream.IsEOF());
 }
 
 TEST_F(UploadDataStreamTest, Chunk) {
-  const uint64 kStreamSize = kTestDataSize*2;
+  const uint64 kStreamSize = kTestDataSize * 2;
   UploadDataStream stream(UploadDataStream::CHUNKED, 0);
   stream.AppendChunk(kTestData, kTestDataSize, false);
   stream.AppendChunk(kTestData, kTestDataSize, true);
 
   ASSERT_EQ(OK, stream.Init(CompletionCallback()));
   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);
@@ skipping 72 matching lines @@
   UploadDataStream stream(element_readers_.Pass(), 0);
 
   // Run Init().
   TestCompletionCallback callback;
   ASSERT_EQ(ERR_IO_PENDING, stream.Init(callback.callback()));
   EXPECT_EQ(ERR_FAILED, callback.WaitForResult());
 }
 
 // Read with a buffer whose size is same as the data.
 TEST_F(UploadDataStreamTest, ReadAsyncWithExactSizeBuffer) {
-  element_readers_.push_back(new UploadBytesElementReader(
-      kTestData, kTestDataSize));
+  element_readers_.push_back(
+      new UploadBytesElementReader(kTestData, kTestDataSize));
   UploadDataStream stream(element_readers_.Pass(), 0);
 
   ASSERT_EQ(OK, stream.Init(CompletionCallback()));
   EXPECT_TRUE(stream.IsInMemory());
   EXPECT_EQ(kTestDataSize, stream.size());
   EXPECT_EQ(0U, stream.position());
   EXPECT_FALSE(stream.IsEOF());
   scoped_refptr<IOBuffer> buf = new IOBuffer(kTestDataSize);
   int bytes_read = stream.Read(buf.get(), kTestDataSize, CompletionCallback());
   ASSERT_EQ(static_cast<int>(kTestDataSize), bytes_read);  // Not an error.
@@ skipping 71 matching lines @@
   ASSERT_EQ(ERR_IO_PENDING, stream.Init(init_callback.callback()));
   int error_code = init_callback.WaitForResult();
   if (error_expected)
     ASSERT_EQ(ERR_UPLOAD_FILE_CHANGED, error_code);
   else
     ASSERT_EQ(OK, error_code);
 }
 
 TEST_F(UploadDataStreamTest, FileChanged) {
   base::FilePath temp_file_path;
-  ASSERT_TRUE(base::CreateTemporaryFileInDir(temp_dir_.path(),
-                                             &temp_file_path));
+  ASSERT_TRUE(
+      base::CreateTemporaryFileInDir(temp_dir_.path(), &temp_file_path));
   ASSERT_EQ(static_cast<int>(kTestDataSize),
             base::WriteFile(temp_file_path, kTestData, kTestDataSize));
 
   base::File::Info file_info;
   ASSERT_TRUE(base::GetFileInfo(temp_file_path, &file_info));
 
   // Test file not changed.
   FileChangedHelper(temp_file_path, file_info.last_modified, false);
 
   // Test file changed.
   FileChangedHelper(temp_file_path,
                     file_info.last_modified - base::TimeDelta::FromSeconds(1),
                     true);
 }
 
 TEST_F(UploadDataStreamTest, MultipleInit) {
   base::FilePath temp_file_path;
-  ASSERT_TRUE(base::CreateTemporaryFileInDir(temp_dir_.path(),
-                                             &temp_file_path));
+  ASSERT_TRUE(
+      base::CreateTemporaryFileInDir(temp_dir_.path(), &temp_file_path));
   ASSERT_EQ(static_cast<int>(kTestDataSize),
             base::WriteFile(temp_file_path, kTestData, kTestDataSize));
 
   // Prepare data.
-  element_readers_.push_back(new UploadBytesElementReader(
-      kTestData, kTestDataSize));
+  element_readers_.push_back(
+      new UploadBytesElementReader(kTestData, kTestDataSize));
   element_readers_.push_back(
       new UploadFileElementReader(base::MessageLoopProxy::current().get(),
                                   temp_file_path,
                                   0,
                                   kuint64max,
                                   base::Time()));
   UploadDataStream stream(element_readers_.Pass(), 0);
 
   std::string expected_data(kTestData, kTestData + kTestDataSize);
   expected_data += expected_data;
 
   // Call Init().
   TestCompletionCallback init_callback1;
   ASSERT_EQ(ERR_IO_PENDING, stream.Init(init_callback1.callback()));
   ASSERT_EQ(OK, init_callback1.WaitForResult());
   EXPECT_FALSE(stream.IsEOF());
-  EXPECT_EQ(kTestDataSize*2, stream.size());
+  EXPECT_EQ(kTestDataSize * 2, stream.size());
 
   // Read.
   EXPECT_EQ(expected_data, ReadFromUploadDataStream(&stream));
   EXPECT_TRUE(stream.IsEOF());
 
   // Call Init() again to reset.
   TestCompletionCallback init_callback2;
   ASSERT_EQ(ERR_IO_PENDING, stream.Init(init_callback2.callback()));
   ASSERT_EQ(OK, init_callback2.WaitForResult());
   EXPECT_FALSE(stream.IsEOF());
-  EXPECT_EQ(kTestDataSize*2, stream.size());
+  EXPECT_EQ(kTestDataSize * 2, stream.size());
 
   // Read again.
   EXPECT_EQ(expected_data, ReadFromUploadDataStream(&stream));
   EXPECT_TRUE(stream.IsEOF());
 }
 
 TEST_F(UploadDataStreamTest, MultipleInitAsync) {
   base::FilePath temp_file_path;
-  ASSERT_TRUE(base::CreateTemporaryFileInDir(temp_dir_.path(),
-                                             &temp_file_path));
+  ASSERT_TRUE(
+      base::CreateTemporaryFileInDir(temp_dir_.path(), &temp_file_path));
   ASSERT_EQ(static_cast<int>(kTestDataSize),
             base::WriteFile(temp_file_path, kTestData, kTestDataSize));
   TestCompletionCallback test_callback;
 
   // Prepare data.
-  element_readers_.push_back(new UploadBytesElementReader(
-      kTestData, kTestDataSize));
+  element_readers_.push_back(
+      new UploadBytesElementReader(kTestData, kTestDataSize));
   element_readers_.push_back(
       new UploadFileElementReader(base::MessageLoopProxy::current().get(),
                                   temp_file_path,
                                   0,
                                   kuint64max,
                                   base::Time()));
   UploadDataStream stream(element_readers_.Pass(), 0);
 
   std::string expected_data(kTestData, kTestData + kTestDataSize);
   expected_data += expected_data;
 
   // Call Init().
   ASSERT_EQ(ERR_IO_PENDING, stream.Init(test_callback.callback()));
   EXPECT_EQ(OK, test_callback.WaitForResult());
   EXPECT_FALSE(stream.IsEOF());
-  EXPECT_EQ(kTestDataSize*2, stream.size());
+  EXPECT_EQ(kTestDataSize * 2, stream.size());
 
   // Read.
   EXPECT_EQ(expected_data, ReadFromUploadDataStream(&stream));
   EXPECT_TRUE(stream.IsEOF());
 
   // Call Init() again to reset.
   ASSERT_EQ(ERR_IO_PENDING, stream.Init(test_callback.callback()));
   EXPECT_EQ(OK, test_callback.WaitForResult());
   EXPECT_FALSE(stream.IsEOF());
-  EXPECT_EQ(kTestDataSize*2, stream.size());
+  EXPECT_EQ(kTestDataSize * 2, stream.size());
 
   // Read again.
   EXPECT_EQ(expected_data, ReadFromUploadDataStream(&stream));
   EXPECT_TRUE(stream.IsEOF());
 }
 
 TEST_F(UploadDataStreamTest, InitToReset) {
   base::FilePath temp_file_path;
-  ASSERT_TRUE(base::CreateTemporaryFileInDir(temp_dir_.path(),
-                                             &temp_file_path));
+  ASSERT_TRUE(
+      base::CreateTemporaryFileInDir(temp_dir_.path(), &temp_file_path));
   ASSERT_EQ(static_cast<int>(kTestDataSize),
             base::WriteFile(temp_file_path, kTestData, kTestDataSize));
 
   // Prepare data.
-  element_readers_.push_back(new UploadBytesElementReader(
-      kTestData, kTestDataSize));
+  element_readers_.push_back(
+      new UploadBytesElementReader(kTestData, kTestDataSize));
   element_readers_.push_back(
       new UploadFileElementReader(base::MessageLoopProxy::current().get(),
                                   temp_file_path,
                                   0,
                                   kuint64max,
                                   base::Time()));
   UploadDataStream stream(element_readers_.Pass(), 0);
 
   std::vector<char> expected_data(kTestData, kTestData + kTestDataSize);
-  expected_data.insert(expected_data.end(), expected_data.begin(),
+  expected_data.insert(expected_data.end(),
+                       expected_data.begin(),
                        expected_data.begin() + kTestDataSize);
 
   // Call Init().
   TestCompletionCallback init_callback1;
   ASSERT_EQ(ERR_IO_PENDING, stream.Init(init_callback1.callback()));
   EXPECT_EQ(OK, init_callback1.WaitForResult());
   EXPECT_FALSE(stream.IsEOF());
-  EXPECT_EQ(kTestDataSize*2, stream.size());
+  EXPECT_EQ(kTestDataSize * 2, stream.size());
 
   // Read some.
   TestCompletionCallback read_callback1;
-  std::vector<char> buf(kTestDataSize + kTestDataSize/2);
+  std::vector<char> buf(kTestDataSize + kTestDataSize / 2);
   scoped_refptr<IOBuffer> wrapped_buffer = new WrappedIOBuffer(&buf[0]);
   EXPECT_EQ(
       ERR_IO_PENDING,
       stream.Read(wrapped_buffer.get(), buf.size(), read_callback1.callback()));
   EXPECT_EQ(static_cast<int>(buf.size()), read_callback1.WaitForResult());
   EXPECT_EQ(buf.size(), stream.position());
 
   // Call Init to reset the state.
   TestCompletionCallback init_callback2;
   ASSERT_EQ(ERR_IO_PENDING, stream.Init(init_callback2.callback()));
   EXPECT_EQ(OK, init_callback2.WaitForResult());
   EXPECT_FALSE(stream.IsEOF());
-  EXPECT_EQ(kTestDataSize*2, stream.size());
+  EXPECT_EQ(kTestDataSize * 2, stream.size());
 
   // Read.
   TestCompletionCallback read_callback2;
-  std::vector<char> buf2(kTestDataSize*2);
+  std::vector<char> buf2(kTestDataSize * 2);
   scoped_refptr<IOBuffer> wrapped_buffer2 = new WrappedIOBuffer(&buf2[0]);
   EXPECT_EQ(ERR_IO_PENDING,
             stream.Read(
                 wrapped_buffer2.get(), buf2.size(), read_callback2.callback()));
   EXPECT_EQ(static_cast<int>(buf2.size()), read_callback2.WaitForResult());
   EXPECT_EQ(expected_data, buf2);
 }
 
 TEST_F(UploadDataStreamTest, InitDuringAsyncInit) {
   base::FilePath temp_file_path;
-  ASSERT_TRUE(base::CreateTemporaryFileInDir(temp_dir_.path(),
-                                             &temp_file_path));
+  ASSERT_TRUE(
+      base::CreateTemporaryFileInDir(temp_dir_.path(), &temp_file_path));
   ASSERT_EQ(static_cast<int>(kTestDataSize),
             base::WriteFile(temp_file_path, kTestData, kTestDataSize));
 
   // Prepare data.
-  element_readers_.push_back(new UploadBytesElementReader(
-      kTestData, kTestDataSize));
+  element_readers_.push_back(
+      new UploadBytesElementReader(kTestData, kTestDataSize));
   element_readers_.push_back(
       new UploadFileElementReader(base::MessageLoopProxy::current().get(),
                                   temp_file_path,
                                   0,
                                   kuint64max,
                                   base::Time()));
   UploadDataStream stream(element_readers_.Pass(), 0);
 
   std::vector<char> expected_data(kTestData, kTestData + kTestDataSize);
-  expected_data.insert(expected_data.end(), expected_data.begin(),
+  expected_data.insert(expected_data.end(),
+                       expected_data.begin(),
                        expected_data.begin() + kTestDataSize);
 
   // Start Init.
   TestCompletionCallback init_callback1;
   EXPECT_EQ(ERR_IO_PENDING, stream.Init(init_callback1.callback()));
 
   // Call Init again to cancel the previous init.
   TestCompletionCallback init_callback2;
   EXPECT_EQ(ERR_IO_PENDING, stream.Init(init_callback2.callback()));
   EXPECT_EQ(OK, init_callback2.WaitForResult());
   EXPECT_FALSE(stream.IsEOF());
-  EXPECT_EQ(kTestDataSize*2, stream.size());
+  EXPECT_EQ(kTestDataSize * 2, stream.size());
 
   // Read.
   TestCompletionCallback read_callback2;
-  std::vector<char> buf2(kTestDataSize*2);
+  std::vector<char> buf2(kTestDataSize * 2);
   scoped_refptr<IOBuffer> wrapped_buffer2 = new WrappedIOBuffer(&buf2[0]);
   EXPECT_EQ(ERR_IO_PENDING,
             stream.Read(
                 wrapped_buffer2.get(), buf2.size(), read_callback2.callback()));
   EXPECT_EQ(static_cast<int>(buf2.size()), read_callback2.WaitForResult());
   EXPECT_EQ(expected_data, buf2);
   EXPECT_TRUE(stream.IsEOF());
 
   // Make sure callbacks are not called for cancelled operations.
   EXPECT_FALSE(init_callback1.have_result());
 }
 
 TEST_F(UploadDataStreamTest, InitDuringAsyncRead) {
   base::FilePath temp_file_path;
-  ASSERT_TRUE(base::CreateTemporaryFileInDir(temp_dir_.path(),
-                                             &temp_file_path));
+  ASSERT_TRUE(
+      base::CreateTemporaryFileInDir(temp_dir_.path(), &temp_file_path));
   ASSERT_EQ(static_cast<int>(kTestDataSize),
             base::WriteFile(temp_file_path, kTestData, kTestDataSize));
 
   // Prepare data.
-  element_readers_.push_back(new UploadBytesElementReader(
-      kTestData, kTestDataSize));
+  element_readers_.push_back(
+      new UploadBytesElementReader(kTestData, kTestDataSize));
   element_readers_.push_back(
       new UploadFileElementReader(base::MessageLoopProxy::current().get(),
                                   temp_file_path,
                                   0,
                                   kuint64max,
                                   base::Time()));
   UploadDataStream stream(element_readers_.Pass(), 0);
 
   std::vector<char> expected_data(kTestData, kTestData + kTestDataSize);
-  expected_data.insert(expected_data.end(), expected_data.begin(),
+  expected_data.insert(expected_data.end(),
+                       expected_data.begin(),
                        expected_data.begin() + kTestDataSize);
 
   // Call Init().
   TestCompletionCallback init_callback1;
   ASSERT_EQ(ERR_IO_PENDING, stream.Init(init_callback1.callback()));
   EXPECT_EQ(OK, init_callback1.WaitForResult());
   EXPECT_FALSE(stream.IsEOF());
-  EXPECT_EQ(kTestDataSize*2, stream.size());
+  EXPECT_EQ(kTestDataSize * 2, stream.size());
 
   // Start reading.
   TestCompletionCallback read_callback1;
-  std::vector<char> buf(kTestDataSize*2);
+  std::vector<char> buf(kTestDataSize * 2);
   scoped_refptr<IOBuffer> wrapped_buffer = new WrappedIOBuffer(&buf[0]);
   EXPECT_EQ(
       ERR_IO_PENDING,
       stream.Read(wrapped_buffer.get(), buf.size(), read_callback1.callback()));
 
   // Call Init to cancel the previous read.
   TestCompletionCallback init_callback2;
   EXPECT_EQ(ERR_IO_PENDING, stream.Init(init_callback2.callback()));
   EXPECT_EQ(OK, init_callback2.WaitForResult());
   EXPECT_FALSE(stream.IsEOF());
-  EXPECT_EQ(kTestDataSize*2, stream.size());
+  EXPECT_EQ(kTestDataSize * 2, stream.size());
 
   // Read.
   TestCompletionCallback read_callback2;
-  std::vector<char> buf2(kTestDataSize*2);
+  std::vector<char> buf2(kTestDataSize * 2);
   scoped_refptr<IOBuffer> wrapped_buffer2 = new WrappedIOBuffer(&buf2[0]);
   EXPECT_EQ(ERR_IO_PENDING,
             stream.Read(
                 wrapped_buffer2.get(), buf2.size(), read_callback2.callback()));
   EXPECT_EQ(static_cast<int>(buf2.size()), read_callback2.WaitForResult());
   EXPECT_EQ(expected_data, buf2);
   EXPECT_TRUE(stream.IsEOF());
 
   // Make sure callbacks are not called for cancelled operations.
   EXPECT_FALSE(read_callback1.have_result());
 }
 
 }  // namespace net