Clang format slam.

net/url_request/url_request_job.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/url_request/url_request_job.h"
 
 #include "base/bind.h"
 #include "base/compiler_specific.h"
 #include "base/message_loop/message_loop.h"
 #include "base/power_monitor/power_monitor.h"
@@ skipping 47 matching lines @@
     NotifyCanceled();
 }
 
 void URLRequestJob::DetachRequest() {
   request_ = NULL;
 }
 
 // This function calls ReadData to get stream data. If a filter exists, passes
 // the data to the attached filter. Then returns the output from filter back to
 // the caller.
-bool URLRequestJob::Read(IOBuffer* buf, int buf_size, int *bytes_read) {
+bool URLRequestJob::Read(IOBuffer* buf, int buf_size, int* bytes_read) {
   bool rv = false;
 
   DCHECK_LT(buf_size, 1000000);  // Sanity check.
   DCHECK(buf);
   DCHECK(bytes_read);
   DCHECK(filtered_read_buffer_.get() == NULL);
   DCHECK_EQ(0, filtered_read_buffer_len_);
 
   *bytes_read = 0;
 
   // Skip Filter if not present.
   if (!filter_.get()) {
     rv = ReadRawDataHelper(buf, buf_size, bytes_read);
   } else {
     // Save the caller's buffers while we do IO
     // in the filter's buffers.
     filtered_read_buffer_ = buf;
     filtered_read_buffer_len_ = buf_size;
 
     if (ReadFilteredData(bytes_read)) {
-      rv = true;   // We have data to return.
+      rv = true;  // We have data to return.
 
       // It is fine to call DoneReading even if ReadFilteredData receives 0
       // bytes from the net, but we avoid making that call if we know for
       // sure that's the case (ReadRawDataHelper path).
       if (*bytes_read == 0)
         DoneReading();
     } else {
       rv = false;  // Error, or a new IO is pending.
     }
   }
@@ skipping 35 matching lines @@
 }
 
 bool URLRequestJob::GetResponseCookies(std::vector<std::string>* cookies) {
   return false;
 }
 
 Filter* URLRequestJob::SetupFilter() const {
   return NULL;
 }
 
-bool URLRequestJob::IsRedirectResponse(GURL* location,
-                                       int* http_status_code) {
+bool URLRequestJob::IsRedirectResponse(GURL* location, int* http_status_code) {
   // For non-HTTP jobs, headers will be null.
   HttpResponseHeaders* headers = request_->response_headers();
   if (!headers)
     return false;
 
   std::string value;
   if (!headers->IsRedirect(&value))
     return false;
 
   *location = request_->url().Resolve(value);
@@ skipping 25 matching lines @@
   // case the derived class should implement this!
   NOTREACHED();
 }
 
 void URLRequestJob::CancelAuth() {
   // This will only be called if NeedsAuth() returns true, in which
   // case the derived class should implement this!
   NOTREACHED();
 }
 
-void URLRequestJob::ContinueWithCertificate(
-    X509Certificate* client_cert) {
+void URLRequestJob::ContinueWithCertificate(X509Certificate* client_cert) {
   // The derived class should implement this!
   NOTREACHED();
 }
 
 void URLRequestJob::ContinueDespiteLastError() {
   // Implementations should know how to recover from errors they generate.
   // If this code was reached, we are trying to recover from an error that
   // we don't know how to recover from.
   NOTREACHED();
 }
@@ skipping 188 matching lines @@
 
   request_->NotifyResponseStarted();
 }
 
 void URLRequestJob::NotifyReadComplete(int bytes_read) {
   if (!request_ || !request_->has_delegate())
     return;  // The request was destroyed, so there is no more work to do.
 
   // TODO(darin): Bug 1004233. Re-enable this test once all of the chrome
   // unit_tests have been fixed to not trip this.
-  //DCHECK(!request_->status().is_io_pending());
+  // DCHECK(!request_->status().is_io_pending());
 
   // The headers should be complete before reads complete
   DCHECK(has_handled_response_);
 
   OnRawReadComplete(bytes_read);
 
   // Don't notify if we had an error.
   if (!request_->status().is_success())
     return;
 
@@ skipping 18 matching lines @@
   } else {
     request_->NotifyReadCompleted(bytes_read);
   }
   DVLOG(1) << __FUNCTION__ << "() "
            << "\"" << (request_ ? request_->url().spec() : "???") << "\""
            << " pre bytes read = " << bytes_read
            << " pre total = " << prefilter_bytes_read_
            << " post total = " << postfilter_bytes_read_;
 }
 
-void URLRequestJob::NotifyStartError(const URLRequestStatus &status) {
+void URLRequestJob::NotifyStartError(const URLRequestStatus& status) {
   DCHECK(!has_handled_response_);
   has_handled_response_ = true;
   if (request_) {
     // There may be relevant information in the response info even in the
     // error case.
     GetResponseInfo(&request_->response_info_);
 
     request_->set_status(status);
     request_->NotifyResponseStarted();
     // We may have been deleted.
   }
 }
 
-void URLRequestJob::NotifyDone(const URLRequestStatus &status) {
+void URLRequestJob::NotifyDone(const URLRequestStatus& status) {
   DCHECK(!done_) << "Job sending done notification twice";
   if (done_)
     return;
   done_ = true;
 
   // Unless there was an error, we should have at least tried to handle
   // the response before getting here.
   DCHECK(has_handled_response_ || !status.is_success());
 
   // As with NotifyReadComplete, we need to take care to notice if we were
@@ skipping 18 matching lines @@
   // Complete this notification later.  This prevents us from re-entering the
   // delegate if we're done because of a synchronous call.
   base::MessageLoop::current()->PostTask(
       FROM_HERE,
       base::Bind(&URLRequestJob::CompleteNotifyDone,
                  weak_factory_.GetWeakPtr()));
 }
 
 void URLRequestJob::CompleteNotifyDone() {
   // Check if we should notify the delegate that we're done because of an error.
-  if (request_ &&
-      !request_->status().is_success() &&
+  if (request_ && !request_->status().is_success() &&
       request_->has_delegate()) {
     // We report the error differently depending on whether we've called
     // OnResponseStarted yet.
     if (has_handled_response_) {
       // We signal the error by calling OnReadComplete with a bytes_read of -1.
       request_->NotifyReadCompleted(-1);
     } else {
       has_handled_response_ = true;
       request_->NotifyResponseStarted();
     }
@@ skipping 13 matching lines @@
 }
 
 void URLRequestJob::OnCallToDelegate() {
   request_->OnCallToDelegate();
 }
 
 void URLRequestJob::OnCallToDelegateComplete() {
   request_->OnCallToDelegateComplete();
 }
 
-bool URLRequestJob::ReadRawData(IOBuffer* buf, int buf_size,
-                                int *bytes_read) {
+bool URLRequestJob::ReadRawData(IOBuffer* buf, int buf_size, int* bytes_read) {
   DCHECK(bytes_read);
   *bytes_read = 0;
   return true;
 }
 
 void URLRequestJob::DoneReading() {
   // Do nothing.
 }
 
 void URLRequestJob::DoneReadingRedirectResponse() {
@@ skipping 79 matching lines @@
         }
         case Filter::FILTER_OK: {
           *bytes_read = filtered_data_len;
           postfilter_bytes_read_ += filtered_data_len;
           rv = true;
           break;
         }
         case Filter::FILTER_ERROR: {
           DVLOG(1) << __FUNCTION__ << "() "
                    << "\"" << (request_ ? request_->url().spec() : "???")
-                   << "\"" << " Filter Error";
+                   << "\""
+                   << " Filter Error";
           filter_needs_more_output_space_ = false;
           NotifyDone(URLRequestStatus(URLRequestStatus::FAILED,
-                     ERR_CONTENT_DECODING_FAILED));
+                                      ERR_CONTENT_DECODING_FAILED));
           rv = false;
           break;
         }
         default: {
           NOTREACHED();
           filter_needs_more_output_space_ = false;
           rv = false;
           break;
         }
       }
 
       // If logging all bytes is enabled, log the filtered bytes read.
       if (rv && request() && request()->net_log().IsLoggingBytes() &&
           filtered_data_len > 0) {
         request()->net_log().AddByteTransferEvent(
             NetLog::TYPE_URL_REQUEST_JOB_FILTERED_BYTES_READ,
-            filtered_data_len, filtered_read_buffer_->data());
+            filtered_data_len,
+            filtered_read_buffer_->data());
       }
     } else {
       // we are done, or there is no data left.
       rv = true;
     }
     break;
   }
 
   if (rv) {
     // When we successfully finished a read, we no longer need to save the
     // caller's buffers. Release our reference.
     filtered_read_buffer_ = NULL;
     filtered_read_buffer_len_ = 0;
   }
   return rv;
 }
 
 void URLRequestJob::DestroyFilters() {
   filter_.reset();
 }
 
 const URLRequestStatus URLRequestJob::GetStatus() {
   if (request_)
     return request_->status();
   // If the request is gone, we must be cancelled.
-  return URLRequestStatus(URLRequestStatus::CANCELED,
-                          ERR_ABORTED);
+  return URLRequestStatus(URLRequestStatus::CANCELED, ERR_ABORTED);
 }
 
-void URLRequestJob::SetStatus(const URLRequestStatus &status) {
+void URLRequestJob::SetStatus(const URLRequestStatus& status) {
   if (request_)
     request_->set_status(status);
 }
 
 bool URLRequestJob::ReadRawDataForFilter(int* bytes_read) {
   bool rv = false;
 
   DCHECK(bytes_read);
   DCHECK(filter_.get());
 
   *bytes_read = 0;
 
   // Get more pre-filtered data if needed.
   // TODO(mbelshe): is it possible that the filter needs *MORE* data
   //    when there is some data already in the buffer?
   if (!filter_->stream_data_len() && !is_done()) {
     IOBuffer* stream_buffer = filter_->stream_buffer();
     int stream_buffer_size = filter_->stream_buffer_size();
     rv = ReadRawDataHelper(stream_buffer, stream_buffer_size, bytes_read);
   }
   return rv;
 }
 
-bool URLRequestJob::ReadRawDataHelper(IOBuffer* buf, int buf_size,
+bool URLRequestJob::ReadRawDataHelper(IOBuffer* buf,
+                                      int buf_size,
                                       int* bytes_read) {
   DCHECK(!request_->status().is_io_pending());
   DCHECK(raw_read_buffer_.get() == NULL);
 
   // Keep a pointer to the read buffer, so we have access to it in the
   // OnRawReadComplete() callback in the event that the read completes
   // asynchronously.
   raw_read_buffer_ = buf;
   bool rv = ReadRawData(buf, buf_size, bytes_read);
 
@@ skipping 12 matching lines @@
     NotifyDone(URLRequestStatus(URLRequestStatus::FAILED, rv));
 }
 
 void URLRequestJob::OnRawReadComplete(int bytes_read) {
   DCHECK(raw_read_buffer_.get());
   // If |filter_| is non-NULL, bytes will be logged after it is applied instead.
   if (!filter_.get() && request() && request()->net_log().IsLoggingBytes() &&
       bytes_read > 0) {
     request()->net_log().AddByteTransferEvent(
         NetLog::TYPE_URL_REQUEST_JOB_BYTES_READ,
-        bytes_read, raw_read_buffer_->data());
+        bytes_read,
+        raw_read_buffer_->data());
   }
 
   if (bytes_read > 0) {
     RecordBytesRead(bytes_read);
   }
   raw_read_buffer_ = NULL;
 }
 
 void URLRequestJob::RecordBytesRead(int bytes_read) {
   filter_input_byte_count_ += bytes_read;
   prefilter_bytes_read_ += bytes_read;
   if (!filter_.get())
     postfilter_bytes_read_ += bytes_read;
   DVLOG(2) << __FUNCTION__ << "() "
            << "\"" << (request_ ? request_->url().spec() : "???") << "\""
            << " pre bytes read = " << bytes_read
            << " pre total = " << prefilter_bytes_read_
            << " post total = " << postfilter_bytes_read_;
   UpdatePacketReadTimes();  // Facilitate stats recording if it is active.
   if (network_delegate_)
     network_delegate_->NotifyRawBytesRead(*request_, bytes_read);
 }
 
 bool URLRequestJob::FilterHasData() {
-    return filter_.get() && filter_->stream_data_len();
+  return filter_.get() && filter_->stream_data_len();
 }
 
 void URLRequestJob::UpdatePacketReadTimes() {
 }
 
 }  // namespace net