Submitting ByteStream chrome class for Google C++ Readability Review.

content/browser/download/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/download/byte_stream.h"
 
 #include "base/bind.h"
 #include "base/location.h"
 #include "base/memory/weak_ptr.h"
 #include "base/memory/ref_counted.h"
@@ skipping 15 matching lines @@
 class ByteStreamReaderImpl;
 
 // A poor man's weak pointer; a RefCountedThreadSafe boolean that can be
 // cleared in an object destructor and accessed to check for object
 // existence.  We can't use weak pointers because they're tightly tied to
 // threads rather than task runners.
 // TODO(rdsmith): A better solution would be extending weak pointers
 // to support SequencedTaskRunners.
 struct LifetimeFlag : public base::RefCountedThreadSafe<LifetimeFlag> {
  public:
-  LifetimeFlag() : is_alive_(true) { }
-  bool is_alive_;
+  LifetimeFlag() : is_alive(true) { }
+  bool is_alive;
 
  protected:
   friend class base::RefCountedThreadSafe<LifetimeFlag>;
   virtual ~LifetimeFlag() { }
 
  private:
   DISALLOW_COPY_AND_ASSIGN(LifetimeFlag);
 };
 
 // For both ByteStreamWriterImpl and ByteStreamReaderImpl, Construction and
 // SetPeer may happen anywhere; all other operations on each class must
 // happen in the context of their SequencedTaskRunner.
 class ByteStreamWriterImpl : public content::ByteStreamWriter {
  public:
   ByteStreamWriterImpl(scoped_refptr<base::SequencedTaskRunner> task_runner,
-                      scoped_refptr<LifetimeFlag> lifetime_flag,
-                      size_t buffer_size);
+                       scoped_refptr<LifetimeFlag> lifetime_flag,
+                       size_t buffer_size);
   virtual ~ByteStreamWriterImpl();
 
   // Must be called before any operations are performed.
   void SetPeer(ByteStreamReaderImpl* peer,
                scoped_refptr<base::SequencedTaskRunner> peer_task_runner,
                scoped_refptr<LifetimeFlag> peer_lifetime_flag);
 
   // Overridden from ByteStreamWriter.
   virtual bool Write(scoped_refptr<net::IOBuffer> buffer,
                      size_t byte_count) OVERRIDE;
@@ skipping 120 matching lines @@
     scoped_refptr<base::SequencedTaskRunner> task_runner,
     scoped_refptr<LifetimeFlag> lifetime_flag,
     size_t buffer_size)
     : total_buffer_size_(buffer_size),
       my_task_runner_(task_runner),
       my_lifetime_flag_(lifetime_flag),
       input_contents_size_(0),
       output_size_used_(0),
       peer_(NULL) {
   DCHECK(my_lifetime_flag_.get());
-  my_lifetime_flag_->is_alive_ = true;
+  my_lifetime_flag_->is_alive = true;
 }
 
 ByteStreamWriterImpl::~ByteStreamWriterImpl() {
-  my_lifetime_flag_->is_alive_ = false;
+  my_lifetime_flag_->is_alive = false;
 }
 
 void ByteStreamWriterImpl::SetPeer(
     ByteStreamReaderImpl* peer,
     scoped_refptr<base::SequencedTaskRunner> peer_task_runner,
     scoped_refptr<LifetimeFlag> peer_lifetime_flag) {
   peer_ = peer;
   peer_task_runner_ = peer_task_runner;
   peer_lifetime_flag_ = peer_lifetime_flag;
 }
@@ skipping 22 matching lines @@
     const base::Closure& source_callback) {
   DCHECK(my_task_runner_->RunsTasksOnCurrentThread());
   space_available_callback_ = source_callback;
 }
 
 // static
 void ByteStreamWriterImpl::UpdateWindow(
     scoped_refptr<LifetimeFlag> lifetime_flag, ByteStreamWriterImpl* target,
     size_t bytes_consumed) {
   // If the target object isn't alive anymore, we do nothing.
-  if (!lifetime_flag->is_alive_) return;
+  if (!lifetime_flag->is_alive) return;
 
   target->UpdateWindowInternal(bytes_consumed);
 }
 
 void ByteStreamWriterImpl::UpdateWindowInternal(size_t bytes_consumed) {
   DCHECK(my_task_runner_->RunsTasksOnCurrentThread());
   DCHECK_GE(output_size_used_, bytes_consumed);
   output_size_used_ -= bytes_consumed;
 
   // Callback if we were above the limit and we're now <= to it.
@@ skipping 37 matching lines @@
     scoped_refptr<LifetimeFlag> lifetime_flag,
     size_t buffer_size)
     : total_buffer_size_(buffer_size),
       my_task_runner_(task_runner),
       my_lifetime_flag_(lifetime_flag),
       received_status_(false),
       status_(content::DOWNLOAD_INTERRUPT_REASON_NONE),
       unreported_consumed_bytes_(0),
       peer_(NULL) {
   DCHECK(my_lifetime_flag_.get());
-  my_lifetime_flag_->is_alive_ = true;
+  my_lifetime_flag_->is_alive = true;
 }
 
 ByteStreamReaderImpl::~ByteStreamReaderImpl() {
-  my_lifetime_flag_->is_alive_ = false;
+  my_lifetime_flag_->is_alive = false;
 }
 
 void ByteStreamReaderImpl::SetPeer(
     ByteStreamWriterImpl* peer,
     scoped_refptr<base::SequencedTaskRunner> peer_task_runner,
     scoped_refptr<LifetimeFlag> peer_lifetime_flag) {
   peer_ = peer;
   peer_task_runner_ = peer_task_runner;
   peer_lifetime_flag_ = peer_lifetime_flag;
 }
@@ skipping 34 matching lines @@
 
 // static
 void ByteStreamReaderImpl::TransferData(
     scoped_refptr<LifetimeFlag> object_lifetime_flag,
     ByteStreamReaderImpl* target,
     scoped_ptr<ContentVector> transfer_buffer,
     size_t buffer_size,
     bool source_complete,
     content::DownloadInterruptReason status) {
   // If our target is no longer alive, do nothing.
-  if (!object_lifetime_flag->is_alive_) return;
+  if (!object_lifetime_flag->is_alive) return;
 
   target->TransferDataInternal(
       transfer_buffer.Pass(), buffer_size, source_complete, status);
 }
 
 void ByteStreamReaderImpl::TransferDataInternal(
     scoped_ptr<ContentVector> transfer_buffer,
     size_t buffer_size,
     bool source_complete,
     content::DownloadInterruptReason status) {
@@ skipping 61 matching lines @@
   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