Clang format slam.

net/url_request/url_request_http_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_http_job.h"
 
 #include "base/base_switches.h"
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/command_line.h"
@@ skipping 83 matching lines @@
 bool URLRequestHttpJob::HttpFilterContext::GetURL(GURL* gurl) const {
   if (!job_->request())
     return false;
   *gurl = job_->request()->url();
   return true;
 }
 
 bool URLRequestHttpJob::HttpFilterContext::GetContentDisposition(
     std::string* disposition) const {
   HttpResponseHeaders* headers = job_->GetResponseHeaders();
-  void *iter = NULL;
+  void* iter = NULL;
   return headers->EnumerateHeader(&iter, "Content-Disposition", disposition);
 }
 
 base::Time URLRequestHttpJob::HttpFilterContext::GetRequestTime() const {
   return job_->request() ? job_->request()->request_time() : base::Time();
 }
 
 bool URLRequestHttpJob::HttpFilterContext::IsCachedContent() const {
   return job_->is_cached_content_;
 }
@@ skipping 34 matching lines @@
 
   if (!request->context()->http_transaction_factory()) {
     NOTREACHED() << "requires a valid context";
     return new URLRequestErrorJob(
         request, network_delegate, ERR_INVALID_ARGUMENT);
   }
 
   GURL redirect_url;
   if (request->GetHSTSRedirect(&redirect_url)) {
     return new URLRequestRedirectJob(
-        request, network_delegate, redirect_url,
+        request,
+        network_delegate,
+        redirect_url,
         // Use status code 307 to preserve the method, so POST requests work.
-        URLRequestRedirectJob::REDIRECT_307_TEMPORARY_REDIRECT, "HSTS");
+        URLRequestRedirectJob::REDIRECT_307_TEMPORARY_REDIRECT,
+        "HSTS");
   }
   return new URLRequestHttpJob(request,
                                network_delegate,
                                request->context()->http_user_agent_settings());
 }
 
 URLRequestHttpJob::URLRequestHttpJob(
     URLRequest* request,
     NetworkDelegate* network_delegate,
     const HttpUserAgentSettings* http_user_agent_settings)
@@ skipping 82 matching lines @@
   request_info_.method = request_->method();
   request_info_.load_flags = request_->load_flags();
   // Enable privacy mode if cookie settings or flags tell us not send or
   // save cookies.
   bool enable_privacy_mode =
       (request_info_.load_flags & LOAD_DO_NOT_SEND_COOKIES) ||
       (request_info_.load_flags & LOAD_DO_NOT_SAVE_COOKIES) ||
       CanEnablePrivacyMode();
   // Privacy mode could still be disabled in OnCookiesLoaded if we are going
   // to send previously saved cookies.
-  request_info_.privacy_mode = enable_privacy_mode ?
-      PRIVACY_MODE_ENABLED : PRIVACY_MODE_DISABLED;
+  request_info_.privacy_mode =
+      enable_privacy_mode ? PRIVACY_MODE_ENABLED : PRIVACY_MODE_DISABLED;
 
   // Strip Referer from request_info_.extra_headers to prevent, e.g., plugins
   // from overriding headers that are controlled using other means. Otherwise a
   // plugin could set a referrer although sending the referrer is inhibited.
   request_info_.extra_headers.RemoveHeader(HttpRequestHeaders::kReferer);
 
   // Our consumer should have made sure that this is a safe referrer.  See for
   // instance WebCore::FrameLoader::HideReferrer.
   if (referrer.is_valid()) {
     request_info_.extra_headers.SetHeader(HttpRequestHeaders::kReferer,
                                           referrer.spec());
   }
 
   request_info_.extra_headers.SetHeaderIfMissing(
       HttpRequestHeaders::kUserAgent,
-      http_user_agent_settings_ ?
-          http_user_agent_settings_->GetUserAgent() : std::string());
+      http_user_agent_settings_ ? http_user_agent_settings_->GetUserAgent()
+                                : std::string());
 
   AddExtraHeaders();
   AddCookieHeaderAndStart();
 }
 
 void URLRequestHttpJob::Kill() {
   if (!transaction_.get())
     return;
 
   weak_factory_.InvalidateWeakPtrs();
@@ skipping 67 matching lines @@
   DoneWithRequest(ABORTED);
   transaction_.reset();
   response_info_ = NULL;
   receive_headers_end_ = base::TimeTicks();
 }
 
 void URLRequestHttpJob::StartTransaction() {
   if (network_delegate()) {
     OnCallToDelegate();
     int rv = network_delegate()->NotifyBeforeSendHeaders(
-        request_, notify_before_headers_sent_callback_,
+        request_,
+        notify_before_headers_sent_callback_,
         &request_info_.extra_headers);
     // If an extension blocks the request, we rely on the callback to
     // MaybeStartTransactionInternal().
     if (rv == ERR_IO_PENDING)
       return;
     MaybeStartTransactionInternal(rv);
     return;
   }
   StartTransactionInternal();
 }
@@ skipping 20 matching lines @@
 
 void URLRequestHttpJob::StartTransactionInternal() {
   // NOTE: This method assumes that request_info_ is already setup properly.
 
   // If we already have a transaction, then we should restart the transaction
   // with auth provided by auth_credentials_.
 
   int rv;
 
   if (network_delegate()) {
-    network_delegate()->NotifySendHeaders(
-        request_, request_info_.extra_headers);
+    network_delegate()->NotifySendHeaders(request_,
+                                          request_info_.extra_headers);
   }
 
   if (transaction_.get()) {
     rv = transaction_->RestartWithAuth(auth_credentials_, start_callback_);
     auth_credentials_ = AuthCredentials();
   } else {
     DCHECK(request_->context()->http_transaction_factory());
 
     rv = request_->context()->http_transaction_factory()->CreateTransaction(
         priority_, &transaction_);
@@ skipping 29 matching lines @@
   }
 
   if (rv == ERR_IO_PENDING)
     return;
 
   // The transaction started synchronously, but we need to notify the
   // URLRequest delegate via the message loop.
   base::MessageLoop::current()->PostTask(
       FROM_HERE,
       base::Bind(&URLRequestHttpJob::OnStartCompleted,
-                 weak_factory_.GetWeakPtr(), rv));
+                 weak_factory_.GetWeakPtr(),
+                 rv));
 }
 
 void URLRequestHttpJob::AddExtraHeaders() {
   // Supply Accept-Encoding field only if it is not already provided.
   // It should be provided IF the content is known to have restrictions on
   // potential encoding, such as streaming multi-media.
   // For details see bug 47381.
   // TODO(jar, enal): jpeg files etc. should set up a request header if
   // possible. Right now it is done only by buffered_resource_loader and
   // simple_data_source.
   if (!request_info_.extra_headers.HasHeader(
-      HttpRequestHeaders::kAcceptEncoding)) {
-    bool advertise_sdch = SdchManager::Global() &&
+          HttpRequestHeaders::kAcceptEncoding)) {
+    bool advertise_sdch =
+        SdchManager::Global() &&
         SdchManager::Global()->IsInSupportedDomain(request_->url());
     std::string avail_dictionaries;
     if (advertise_sdch) {
       SdchManager::Global()->GetAvailDictionaryList(request_->url(),
                                                     &avail_dictionaries);
 
       // The AllowLatencyExperiment() is only true if we've successfully done a
       // full SDCH compression recently in this browser session for this host.
       // Note that for this path, there might be no applicable dictionaries,
       // and hence we can't participate in the experiment.
@@ skipping 12 matching lines @@
       }
     }
 
     // Supply Accept-Encoding headers first so that it is more likely that they
     // will be in the first transmitted packet.  This can sometimes make it
     // easier to filter and analyze the streams to assure that a proxy has not
     // damaged these headers.  Some proxies deliberately corrupt Accept-Encoding
     // headers.
     if (!advertise_sdch) {
       // Tell the server what compression formats we support (other than SDCH).
-      request_info_.extra_headers.SetHeader(
-          HttpRequestHeaders::kAcceptEncoding, "gzip,deflate");
+      request_info_.extra_headers.SetHeader(HttpRequestHeaders::kAcceptEncoding,
+                                            "gzip,deflate");
     } else {
       // Include SDCH in acceptable list.
-      request_info_.extra_headers.SetHeader(
-          HttpRequestHeaders::kAcceptEncoding, "gzip,deflate,sdch");
+      request_info_.extra_headers.SetHeader(HttpRequestHeaders::kAcceptEncoding,
+                                            "gzip,deflate,sdch");
       if (!avail_dictionaries.empty()) {
-        request_info_.extra_headers.SetHeader(
-            kAvailDictionaryHeader,
-            avail_dictionaries);
+        request_info_.extra_headers.SetHeader(kAvailDictionaryHeader,
+                                              avail_dictionaries);
         sdch_dictionary_advertised_ = true;
         // Since we're tagging this transaction as advertising a dictionary,
         // we'll definitely employ an SDCH filter (or tentative sdch filter)
         // when we get a response.  When done, we'll record histograms via
         // SDCH_DECODE or SDCH_PASSTHROUGH.  Hence we need to record packet
         // arrival times.
         packet_timing_enabled_ = true;
       }
     }
   }
 
   if (http_user_agent_settings_) {
     // Only add default Accept-Language if the request didn't have it
     // specified.
     std::string accept_language =
         http_user_agent_settings_->GetAcceptLanguage();
     if (!accept_language.empty()) {
       request_info_.extra_headers.SetHeaderIfMissing(
-          HttpRequestHeaders::kAcceptLanguage,
-          accept_language);
+          HttpRequestHeaders::kAcceptLanguage, accept_language);
     }
   }
 }
 
 void URLRequestHttpJob::AddCookieHeaderAndStart() {
   // No matter what, we want to report our status as IO pending since we will
   // be notifying our consumer asynchronously via OnStartCompleted.
   SetStatus(URLRequestStatus(URLRequestStatus::IO_PENDING, 0));
 
   // If the request was destroyed, then there is no more work to do.
   if (!request_)
     return;
 
   CookieStore* cookie_store = GetCookieStore();
   if (cookie_store && !(request_info_.load_flags & LOAD_DO_NOT_SEND_COOKIES)) {
     cookie_store->GetAllCookiesForURLAsync(
         request_->url(),
         base::Bind(&URLRequestHttpJob::CheckCookiePolicyAndLoad,
                    weak_factory_.GetWeakPtr()));
   } else {
     DoStartTransaction();
   }
 }
 
 void URLRequestHttpJob::DoLoadCookies() {
   CookieOptions options;
   options.set_include_httponly();
   GetCookieStore()->GetCookiesWithOptionsAsync(
-      request_->url(), options,
+      request_->url(),
+      options,
       base::Bind(&URLRequestHttpJob::OnCookiesLoaded,
                  weak_factory_.GetWeakPtr()));
 }
 
 void URLRequestHttpJob::CheckCookiePolicyAndLoad(
     const CookieList& cookie_list) {
   if (CanGetCookies(cookie_list))
     DoLoadCookies();
   else
     DoStartTransaction();
 }
 
 void URLRequestHttpJob::OnCookiesLoaded(const std::string& cookie_line) {
   if (!cookie_line.empty()) {
-    request_info_.extra_headers.SetHeader(
-        HttpRequestHeaders::kCookie, cookie_line);
+    request_info_.extra_headers.SetHeader(HttpRequestHeaders::kCookie,
+                                          cookie_line);
     // Disable privacy mode as we are sending cookies anyway.
     request_info_.privacy_mode = PRIVACY_MODE_DISABLED;
   }
   DoStartTransaction();
 }
 
 void URLRequestHttpJob::DoStartTransaction() {
   // We may have been canceled while retrieving cookies.
   if (GetStatus().is_success()) {
     StartTransaction();
@@ skipping 57 matching lines @@
     net::CookieStore::SetCookiesCallback callback(
         base::Bind(&URLRequestHttpJob::OnCookieSaved,
                    weak_factory_.GetWeakPtr(),
                    save_next_cookie_running,
                    callback_pending));
 
     // Loop through the cookies as long as SetCookieWithOptionsAsync completes
     // synchronously.
     while (!callback_pending->data &&
            response_cookies_save_index_ < response_cookies_.size()) {
-      if (CanSetCookie(
-          response_cookies_[response_cookies_save_index_], &options)) {
+      if (CanSetCookie(response_cookies_[response_cookies_save_index_],
+                       &options)) {
         callback_pending->data = true;
         GetCookieStore()->SetCookieWithOptionsAsync(
-            request_->url(), response_cookies_[response_cookies_save_index_],
-            options, callback);
+            request_->url(),
+            response_cookies_[response_cookies_save_index_],
+            options,
+            callback);
       }
       ++response_cookies_save_index_;
     }
   }
 
   save_next_cookie_running->data = false;
 
   if (!callback_pending->data) {
     response_cookies_.clear();
     response_cookies_save_index_ = 0;
@@ skipping 106 matching lines @@
   receive_headers_end_ = base::TimeTicks::Now();
 
   // Clear the IO_PENDING status
   SetStatus(URLRequestStatus());
 
   const URLRequestContext* context = request_->context();
 
   if (result == ERR_SSL_PINNED_KEY_NOT_IN_CERT_CHAIN &&
       transaction_->GetResponseInfo() != NULL) {
     FraudulentCertificateReporter* reporter =
-      context->fraudulent_certificate_reporter();
+        context->fraudulent_certificate_reporter();
     if (reporter != NULL) {
       const SSLInfo& ssl_info = transaction_->GetResponseInfo()->ssl_info;
-      bool sni_available = SSLConfigService::IsSNIAvailable(
-          context->ssl_config_service());
+      bool sni_available =
+          SSLConfigService::IsSNIAvailable(context->ssl_config_service());
       const std::string& host = request_->url().host();
 
       reporter->SendReport(host, ssl_info, sni_available);
     }
   }
 
   if (result == OK) {
     scoped_refptr<HttpResponseHeaders> headers = GetResponseHeaders();
     if (network_delegate()) {
       // Note that |this| may not be deleted until
       // |on_headers_received_callback_| or
       // |NetworkDelegate::URLRequestDestroyed()| has been called.
       OnCallToDelegate();
       allowed_unsafe_redirect_url_ = GURL();
       int error = network_delegate()->NotifyHeadersReceived(
           request_,
           on_headers_received_callback_,
           headers.get(),
           &override_response_headers_,
           &allowed_unsafe_redirect_url_);
       if (error != net::OK) {
         if (error == net::ERR_IO_PENDING) {
           awaiting_callback_ = true;
         } else {
           std::string source("delegate");
-          request_->net_log().AddEvent(NetLog::TYPE_CANCELLED,
-                                       NetLog::StringCallback("source",
-                                                              &source));
+          request_->net_log().AddEvent(
+              NetLog::TYPE_CANCELLED,
+              NetLog::StringCallback("source", &source));
           OnCallToDelegateComplete();
           NotifyStartError(URLRequestStatus(URLRequestStatus::FAILED, error));
         }
         return;
       }
     }
 
     SaveCookiesAndNotifyHeadersComplete(net::OK);
   } else if (IsCertificateError(result)) {
     // We encountered an SSL certificate error.
     if (result == ERR_SSL_WEAK_SERVER_EPHEMERAL_DH_KEY ||
         result == ERR_SSL_PINNED_KEY_NOT_IN_CERT_CHAIN) {
       // These are hard failures. They're handled separately and don't have
       // the correct cert status, so set it here.
       SSLInfo info(transaction_->GetResponseInfo()->ssl_info);
       info.cert_status = MapNetErrorToCertStatus(result);
       NotifySSLCertificateError(info, true);
     } else {
       // Maybe overridable, maybe not. Ask the delegate to decide.
       TransportSecurityState::DomainState domain_state;
       const URLRequestContext* context = request_->context();
-      const bool fatal = context->transport_security_state() &&
+      const bool fatal =
+          context->transport_security_state() &&
           context->transport_security_state()->GetDomainState(
               request_info_.url.host(),
               SSLConfigService::IsSNIAvailable(context->ssl_config_service()),
               &domain_state) &&
           domain_state.ShouldSSLErrorsBeFatal();
-      NotifySSLCertificateError(
-          transaction_->GetResponseInfo()->ssl_info, fatal);
+      NotifySSLCertificateError(transaction_->GetResponseInfo()->ssl_info,
+                                fatal);
     }
   } else if (result == ERR_SSL_CLIENT_AUTH_CERT_NEEDED) {
     NotifyCertificateRequested(
         transaction_->GetResponseInfo()->cert_request_info.get());
   } else {
     // Even on an error, there may be useful information in the response
     // info (e.g. whether there's a cached copy).
     if (transaction_.get())
       response_info_ = transaction_->GetResponseInfo();
     NotifyStartError(URLRequestStatus(URLRequestStatus::FAILED, result));
@@ skipping 51 matching lines @@
   request_info_.upload_data_stream = upload;
 }
 
 void URLRequestHttpJob::SetExtraRequestHeaders(
     const HttpRequestHeaders& headers) {
   DCHECK(!transaction_.get()) << "cannot change once started";
   request_info_.extra_headers.CopyFrom(headers);
 }
 
 LoadState URLRequestHttpJob::GetLoadState() const {
-  return transaction_.get() ?
-      transaction_->GetLoadState() : LOAD_STATE_IDLE;
+  return transaction_.get() ? transaction_->GetLoadState() : LOAD_STATE_IDLE;
 }
 
 UploadProgress URLRequestHttpJob::GetUploadProgress() const {
-  return transaction_.get() ?
-      transaction_->GetUploadProgress() : UploadProgress();
+  return transaction_.get() ? transaction_->GetUploadProgress()
+                            : UploadProgress();
 }
 
 bool URLRequestHttpJob::GetMimeType(std::string* mime_type) const {
   DCHECK(transaction_.get());
 
   if (!response_info_)
     return false;
 
   return GetResponseHeaders()->GetMimeType(mime_type);
 }
@@ skipping 66 matching lines @@
   }
 
   if (filter_context_->IsSdchResponse()) {
     // We are wary of proxies that discard or damage SDCH encoding.  If a server
     // explicitly states that this is not SDCH content, then we can correct our
     // assumption that this is an SDCH response, and avoid the need to recover
     // as though the content is corrupted (when we discover it is not SDCH
     // encoded).
     std::string sdch_response_status;
     iter = NULL;
-    while (headers->EnumerateHeader(&iter, "X-Sdch-Encode",
-                                    &sdch_response_status)) {
+    while (headers->EnumerateHeader(
+        &iter, "X-Sdch-Encode", &sdch_response_status)) {
       if (sdch_response_status == "0") {
         filter_context_->ResetSdchResponseToFalse();
         break;
       }
     }
   }
 
   // Even if encoding types are empty, there is a chance that we need to add
   // some decoding, as some proxies strip encoding completely. In such cases,
   // we may need to add (for example) SDCH filtering (when the context suggests
   // it is appropriate).
   Filter::FixupEncodingTypes(*filter_context_, &encoding_types);
 
   return !encoding_types.empty()
-      ? Filter::Factory(encoding_types, *filter_context_) : NULL;
+             ? Filter::Factory(encoding_types, *filter_context_)
+             : NULL;
 }
 
 bool URLRequestHttpJob::CopyFragmentOnRedirect(const GURL& location) const {
   // Allow modification of reference fragments by default, unless
   // |allowed_unsafe_redirect_url_| is set and equal to the redirect URL.
   // When this is the case, we assume that the network delegate has set the
   // desired redirect URL (with or without fragment), so it must not be changed
   // any more.
   return !allowed_unsafe_redirect_url_.is_valid() ||
-       allowed_unsafe_redirect_url_ != location;
+         allowed_unsafe_redirect_url_ != location;
 }
 
 bool URLRequestHttpJob::IsSafeRedirect(const GURL& location) {
   // HTTP is always safe.
   // TODO(pauljensen): Remove once crbug.com/146591 is fixed.
   if (location.is_valid() &&
       (location.scheme() == "http" || location.scheme() == "https")) {
     return true;
   }
   // Delegates may mark a URL as safe for redirection.
   if (allowed_unsafe_redirect_url_.is_valid() &&
       allowed_unsafe_redirect_url_ == location) {
     return true;
   }
   // Query URLRequestJobFactory as to whether |location| would be safe to
   // redirect to.
   return request_->context()->job_factory() &&
-      request_->context()->job_factory()->IsSafeRedirectTarget(location);
+         request_->context()->job_factory()->IsSafeRedirectTarget(location);
 }
 
 bool URLRequestHttpJob::NeedsAuth() {
   int code = GetResponseCode();
   if (code == -1)
     return false;
 
   // Check if we need either Proxy or WWW Authentication.  This could happen
   // because we either provided no auth info, or provided incorrect info.
   switch (code) {
@@ skipping 60 matching lines @@
   //
   // Because we set the AUTH_STATE_CANCELED flag, NeedsAuth will return false,
   // which will cause the consumer to receive OnResponseStarted instead of
   // OnAuthRequired.
   //
   // We have to do this via InvokeLater to avoid "recursing" the consumer.
   //
   base::MessageLoop::current()->PostTask(
       FROM_HERE,
       base::Bind(&URLRequestHttpJob::OnStartCompleted,
-                 weak_factory_.GetWeakPtr(), OK));
+                 weak_factory_.GetWeakPtr(),
+                 OK));
 }
 
-void URLRequestHttpJob::ContinueWithCertificate(
-    X509Certificate* client_cert) {
+void URLRequestHttpJob::ContinueWithCertificate(X509Certificate* client_cert) {
   DCHECK(transaction_.get());
 
   DCHECK(!response_info_) << "should not have a response yet";
   receive_headers_end_ = base::TimeTicks();
 
   ResetTimer();
 
   // No matter what, we want to report our status as IO pending since we will
   // be notifying our consumer asynchronously via OnStartCompleted.
   SetStatus(URLRequestStatus(URLRequestStatus::IO_PENDING, 0));
 
   int rv = transaction_->RestartWithCertificate(client_cert, start_callback_);
   if (rv == ERR_IO_PENDING)
     return;
 
   // The transaction started synchronously, but we need to notify the
   // URLRequest delegate via the message loop.
   base::MessageLoop::current()->PostTask(
       FROM_HERE,
       base::Bind(&URLRequestHttpJob::OnStartCompleted,
-                 weak_factory_.GetWeakPtr(), rv));
+                 weak_factory_.GetWeakPtr(),
+                 rv));
 }
 
 void URLRequestHttpJob::ContinueDespiteLastError() {
   // If the transaction was destroyed, then the job was cancelled.
   if (!transaction_.get())
     return;
 
   DCHECK(!response_info_) << "should not have a response yet";
   receive_headers_end_ = base::TimeTicks();
 
   ResetTimer();
 
   // No matter what, we want to report our status as IO pending since we will
   // be notifying our consumer asynchronously via OnStartCompleted.
   SetStatus(URLRequestStatus(URLRequestStatus::IO_PENDING, 0));
 
   int rv = transaction_->RestartIgnoringLastError(start_callback_);
   if (rv == ERR_IO_PENDING)
     return;
 
   // The transaction started synchronously, but we need to notify the
   // URLRequest delegate via the message loop.
   base::MessageLoop::current()->PostTask(
       FROM_HERE,
       base::Bind(&URLRequestHttpJob::OnStartCompleted,
-                 weak_factory_.GetWeakPtr(), rv));
+                 weak_factory_.GetWeakPtr(),
+                 rv));
 }
 
 void URLRequestHttpJob::ResumeNetworkStart() {
   DCHECK(transaction_.get());
   transaction_->ResumeNetworkStart();
 }
 
 bool URLRequestHttpJob::ShouldFixMismatchedContentLength(int rv) const {
   // Some servers send the body compressed, but specify the content length as
   // the uncompressed size.  Although this violates the HTTP spec we want to
@@ skipping 10 matching lines @@
               << " post total = " << postfilter_bytes_read();
       if (postfilter_bytes_read() == expected_length) {
         // Clear the error.
         return true;
       }
     }
   }
   return false;
 }
 
-bool URLRequestHttpJob::ReadRawData(IOBuffer* buf, int buf_size,
+bool URLRequestHttpJob::ReadRawData(IOBuffer* buf,
+                                    int buf_size,
                                     int* bytes_read) {
   DCHECK_NE(buf_size, 0);
   DCHECK(bytes_read);
   DCHECK(!read_in_progress_);
 
   int rv = transaction_->Read(
-      buf, buf_size,
+      buf,
+      buf_size,
       base::Bind(&URLRequestHttpJob::OnReadCompleted, base::Unretained(this)));
 
   if (ShouldFixMismatchedContentLength(rv))
     rv = 0;
 
   if (rv >= 0) {
     *bytes_read = rv;
     if (!rv)
       DoneWithRequest(FINISHED);
     return true;
@@ skipping 66 matching lines @@
   }
 
   base::TimeDelta to_start = base::Time::Now() - request_creation_time_;
   request_creation_time_ = base::Time();
 
   UMA_HISTOGRAM_MEDIUM_TIMES("Net.HttpTimeToFirstByte", to_start);
 }
 
 void URLRequestHttpJob::ResetTimer() {
   if (!request_creation_time_.is_null()) {
-    NOTREACHED()
-        << "The timer was reset before it was recorded.";
+    NOTREACHED() << "The timer was reset before it was recorded.";
     return;
   }
   request_creation_time_ = base::Time::Now();
 }
 
 void URLRequestHttpJob::UpdatePacketReadTimes() {
   if (!packet_timing_enabled_)
     return;
 
   if (filter_input_byte_count() <= bytes_observed_in_packets_) {
@@ skipping 10 matching lines @@
 
 void URLRequestHttpJob::RecordPacketStats(
     FilterContext::StatisticSelector statistic) const {
   if (!packet_timing_enabled_ || (final_packet_time_ == base::Time()))
     return;
 
   base::TimeDelta duration = final_packet_time_ - request_time_snapshot_;
   switch (statistic) {
     case FilterContext::SDCH_DECODE: {
       UMA_HISTOGRAM_CUSTOM_COUNTS("Sdch3.Network_Decode_Bytes_Processed_b",
-          static_cast<int>(bytes_observed_in_packets_), 500, 100000, 100);
+                                  static_cast<int>(bytes_observed_in_packets_),
+                                  500,
+                                  100000,
+                                  100);
       return;
     }
     case FilterContext::SDCH_PASSTHROUGH: {
       // Despite advertising a dictionary, we handled non-sdch compressed
       // content.
       return;
     }
 
     case FilterContext::SDCH_EXPERIMENT_DECODE: {
       UMA_HISTOGRAM_CUSTOM_TIMES("Sdch3.Experiment2_Decode",
-                                  duration,
-                                  base::TimeDelta::FromMilliseconds(20),
-                                  base::TimeDelta::FromMinutes(10), 100);
+                                 duration,
+                                 base::TimeDelta::FromMilliseconds(20),
+                                 base::TimeDelta::FromMinutes(10),
+                                 100);
       return;
     }
     case FilterContext::SDCH_EXPERIMENT_HOLDBACK: {
       UMA_HISTOGRAM_CUSTOM_TIMES("Sdch3.Experiment2_Holdback",
-                                  duration,
-                                  base::TimeDelta::FromMilliseconds(20),
-                                  base::TimeDelta::FromMinutes(10), 100);
+                                 duration,
+                                 base::TimeDelta::FromMilliseconds(20),
+                                 base::TimeDelta::FromMinutes(10),
+                                 100);
       return;
     }
     default:
       NOTREACHED();
       return;
   }
 }
 
 // The common type of histogram we use for all compression-tracking histograms.
-#define COMPRESSION_HISTOGRAM(name, sample) \
-    do { \
-      UMA_HISTOGRAM_CUSTOM_COUNTS("Net.Compress." name, sample, \
-                                  500, 1000000, 100); \
-    } while (0)
+#define COMPRESSION_HISTOGRAM(name, sample)               \
+  do {                                                    \
+    UMA_HISTOGRAM_CUSTOM_COUNTS(                          \
+        "Net.Compress." name, sample, 500, 1000000, 100); \
+  } while (0)
 
 void URLRequestHttpJob::RecordCompressionHistograms() {
   DCHECK(request_);
   if (!request_)
     return;
 
-  if (is_cached_content_ ||                // Don't record cached content
-      !GetStatus().is_success() ||         // Don't record failed content
-      !IsCompressibleContent() ||          // Only record compressible content
-      !prefilter_bytes_read())       // Zero-byte responses aren't useful.
+  if (is_cached_content_ ||         // Don't record cached content
+      !GetStatus().is_success() ||  // Don't record failed content
+      !IsCompressibleContent() ||   // Only record compressible content
+      !prefilter_bytes_read())      // Zero-byte responses aren't useful.
     return;
 
   // Miniature requests aren't really compressible.  Don't count them.
   const int kMinSize = 16;
   if (prefilter_bytes_read() < kMinSize)
     return;
 
   // Only record for http or https urls.
   bool is_http = request_->url().SchemeIs("http");
   bool is_https = request_->url().SchemeIs("https");
@@ skipping 42 matching lines @@
     COMPRESSION_HISTOGRAM("NoProxy.BytesBeforeCompression", compressed_B);
     COMPRESSION_HISTOGRAM("NoProxy.BytesAfterCompression", decompressed_B);
   } else {
     COMPRESSION_HISTOGRAM("NoProxy.ShouldHaveBeenCompressed", decompressed_B);
   }
 }
 
 bool URLRequestHttpJob::IsCompressibleContent() const {
   std::string mime_type;
   return GetMimeType(&mime_type) &&
-      (IsSupportedJavascriptMimeType(mime_type.c_str()) ||
-       IsSupportedNonImageMimeType(mime_type.c_str()));
+         (IsSupportedJavascriptMimeType(mime_type.c_str()) ||
+          IsSupportedNonImageMimeType(mime_type.c_str()));
 }
 
 void URLRequestHttpJob::RecordPerfHistograms(CompletionCause reason) {
   if (start_time_.is_null())
     return;
 
   base::TimeDelta total_time = base::TimeTicks::Now() - start_time_;
   UMA_HISTOGRAM_TIMES("Net.HttpJob.TotalTime", total_time);
 
   if (reason == FINISHED) {
     UMA_HISTOGRAM_TIMES("Net.HttpJob.TotalTimeSuccess", total_time);
   } else {
     UMA_HISTOGRAM_TIMES("Net.HttpJob.TotalTimeCancel", total_time);
   }
 
   if (response_info_) {
     if (response_info_->was_cached) {
       UMA_HISTOGRAM_TIMES("Net.HttpJob.TotalTimeCached", total_time);
-    } else  {
+    } else {
       UMA_HISTOGRAM_TIMES("Net.HttpJob.TotalTimeNotCached", total_time);
     }
   }
 
   if (request_info_.load_flags & LOAD_PREFETCH && !request_->was_cached())
     UMA_HISTOGRAM_COUNTS("Net.Prefetch.PrefilterBytesReadFromNetwork",
                          prefilter_bytes_read());
 
   start_time_ = base::TimeTicks();
 }
 
 void URLRequestHttpJob::DoneWithRequest(CompletionCause reason) {
   if (done_)
     return;
   done_ = true;
   RecordPerfHistograms(reason);
   if (reason == FINISHED) {
     request_->set_received_response_content_length(prefilter_bytes_read());
     RecordCompressionHistograms();
   }
 }
 
 HttpResponseHeaders* URLRequestHttpJob::GetResponseHeaders() const {
   DCHECK(transaction_.get());
   DCHECK(transaction_->GetResponseInfo());
-  return override_response_headers_.get() ?
-             override_response_headers_.get() :
-             transaction_->GetResponseInfo()->headers.get();
+  return override_response_headers_.get()
+             ? override_response_headers_.get()
+             : transaction_->GetResponseInfo()->headers.get();
 }
 
 void URLRequestHttpJob::NotifyURLRequestDestroyed() {
   awaiting_callback_ = false;
 }
 
 }  // namespace net