Clean up on byte_stream (mainly style and includes)

content/browser/byte_stream.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 "content/browser/byte_stream.h"
 
+#include <deque>
+#include <set>
+#include <utility>
+
 #include "base/bind.h"
 #include "base/location.h"
 #include "base/memory/ref_counted.h"
-#include "base/memory/weak_ptr.h"
 #include "base/sequenced_task_runner.h"
 
 namespace content {
 namespace {
 
 typedef std::deque<std::pair<scoped_refptr<net::IOBuffer>, size_t> >
 ContentVector;
 
 class ByteStreamReaderImpl;
 
@@ skipping 235 matching lines @@
       (total_known_size_used + bytes_consumed > total_buffer_size_) &&
       !space_available_callback_.is_null())
     space_available_callback_.Run();
 }
 
 void ByteStreamWriterImpl::PostToPeer(bool complete, int status) {
   DCHECK(my_task_runner_->RunsTasksOnCurrentThread());
   // Valid contexts in which to call.
   DCHECK(complete || 0 != input_contents_size_);
 
-  scoped_ptr<ContentVector> transfer_buffer(new ContentVector);
+  scoped_ptr<ContentVector> transfer_buffer;

[Randy Smith (Not in Mondays), 2013/08/02 18:43:05]

I believe the answer is yes, but just confirming: Do we have a test for a null
data PostToPeer in the test set?

[tyoshino (SeeGerritForStatus), 2013/08/05 07:53:11]

Added.

   size_t buffer_size = 0;
   if (0 != input_contents_size_) {
     transfer_buffer.reset(new ContentVector);
     transfer_buffer->swap(input_contents_);
     buffer_size = input_contents_size_;
     output_size_used_ += input_contents_size_;
     input_contents_size_ = 0;
   }
   peer_task_runner_->PostTask(
       FROM_HERE, base::Bind(
@@ skipping 86 matching lines @@
     scoped_ptr<ContentVector> transfer_buffer,
     size_t buffer_size,
     bool source_complete,
     int status) {
   DCHECK(my_task_runner_->RunsTasksOnCurrentThread());
 
   bool was_empty = available_contents_.empty();
 
   if (transfer_buffer) {
     available_contents_.insert(available_contents_.end(),
-                                        transfer_buffer->begin(),
-                                        transfer_buffer->end());
+                               transfer_buffer->begin(),
+                               transfer_buffer->end());
   }
 
   if (source_complete) {
     received_status_ = true;
     status_ = status;
   }
 
   // Callback on transition from empty to non-empty, or
   // source complete.
   if (((was_empty && !available_contents_.empty()) ||
@@ skipping 16 matching lines @@
       FROM_HERE, base::Bind(
           &ByteStreamWriterImpl::UpdateWindow,
           peer_lifetime_flag_,
           peer_,
           unreported_consumed_bytes_));
   unreported_consumed_bytes_ = 0;
 }
 
 }  // namespace
 
-
 const int ByteStreamWriter::kFractionBufferBeforeSending = 3;
 const int ByteStreamReader::kFractionReadBeforeWindowUpdate = 3;
 
 ByteStreamReader::~ByteStreamReader() { }
 
 ByteStreamWriter::~ByteStreamWriter() { }
 
 void CreateByteStream(
     scoped_refptr<base::SequencedTaskRunner> input_task_runner,
     scoped_refptr<base::SequencedTaskRunner> output_task_runner,
     size_t buffer_size,
     scoped_ptr<ByteStreamWriter>* input,
     scoped_ptr<ByteStreamReader>* output) {
   scoped_refptr<LifetimeFlag> input_flag(new LifetimeFlag());
   scoped_refptr<LifetimeFlag> output_flag(new LifetimeFlag());
 
   ByteStreamWriterImpl* in = new ByteStreamWriterImpl(
       input_task_runner, input_flag, buffer_size);
   ByteStreamReaderImpl* out = new ByteStreamReaderImpl(
       output_task_runner, output_flag, buffer_size);
 
   in->SetPeer(out, output_task_runner, output_flag);
   out->SetPeer(in, input_task_runner, input_flag);
   input->reset(in);
   output->reset(out);
 }
 
 }  // namespace content