Clang format pdf/

pdf/document_loader.cc

 // Copyright (c) 2010 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 "pdf/document_loader.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include "base/logging.h"
@@ skipping 62 matching lines @@
 // e.g. resource has been removed from the server while loading it. 301
 // indicates a redirect was returned which won't be successful because we
 // disable following redirects for PDF loading (we assume they are already
 // resolved by the browser.
 bool ResponseStatusSuccess(const pp::URLLoader& loader) {
   int32_t http_code = loader.GetResponseInfo().GetStatusCode();
   return (http_code < 400 && http_code != 301) || http_code >= 500;
 }
 
 bool IsValidContentType(const std::string& type) {
-  return (base::EndsWith(type, "/pdf", base::CompareCase::INSENSITIVE_ASCII) ||
-          base::EndsWith(type, ".pdf", base::CompareCase::INSENSITIVE_ASCII) ||
-          base::EndsWith(type, "/x-pdf",
-                         base::CompareCase::INSENSITIVE_ASCII) ||
-          base::EndsWith(type, "/*", base::CompareCase::INSENSITIVE_ASCII) ||
-          base::EndsWith(type, "/acrobat",
-                         base::CompareCase::INSENSITIVE_ASCII) ||
-          base::EndsWith(type, "/unknown",
-                         base::CompareCase::INSENSITIVE_ASCII));
+  return base::EndsWith(type, "/pdf", base::CompareCase::INSENSITIVE_ASCII) ||
+         base::EndsWith(type, ".pdf", base::CompareCase::INSENSITIVE_ASCII) ||
+         base::EndsWith(type, "/x-pdf", base::CompareCase::INSENSITIVE_ASCII) ||
+         base::EndsWith(type, "/*", base::CompareCase::INSENSITIVE_ASCII) ||
+         base::EndsWith(type, "/acrobat",
+                        base::CompareCase::INSENSITIVE_ASCII) ||
+         base::EndsWith(type, "/unknown", base::CompareCase::INSENSITIVE_ASCII);
 }
 
 }  // namespace
 
-DocumentLoader::Client::~Client() {
-}
+DocumentLoader::Client::~Client() {}
 
 DocumentLoader::DocumentLoader(Client* client)
-    : client_(client), partial_document_(false), request_pending_(false),
-      current_pos_(0), current_chunk_size_(0), current_chunk_read_(0),
-      document_size_(0), header_request_(true), is_multipart_(false) {
+    : client_(client),
+      partial_document_(false),
+      request_pending_(false),
+      current_pos_(0),
+      current_chunk_size_(0),
+      current_chunk_read_(0),
+      document_size_(0),
+      header_request_(true),
+      is_multipart_(false) {
   loader_factory_.Initialize(this);
 }
 
-DocumentLoader::~DocumentLoader() {
-}
+DocumentLoader::~DocumentLoader() {}
 
 bool DocumentLoader::Init(const pp::URLLoader& loader,
                           const std::string& url,
                           const std::string& headers) {
   DCHECK(url_.empty());
 
   // Check that the initial response status is a valid one.
   if (!ResponseStatusSuccess(loader))
     return false;
 
@@ skipping 56 matching lines @@
     return false;
 
   if (content_length > 0)
     chunk_stream_.Preallocate(content_length);
 
   document_size_ = content_length;
   requests_count_ = 0;
 
   // Enable partial loading only if file size is above the threshold.
   // It will allow avoiding latency for multiple requests.
-  if (content_length > kMinFileSize &&
-      accept_ranges_bytes &&
+  if (content_length > kMinFileSize && accept_ranges_bytes &&
       !content_encoded) {
     LoadPartialDocument();
   } else {
     LoadFullDocument();
   }
   return true;
 }
 
 void DocumentLoader::LoadPartialDocument() {
   // The current request is a full request (not a range request) so it starts at
@@ skipping 20 matching lines @@
   if (document_size_ == 0)  // Document size unknown.
     return false;
   return IsDataAvailable(0, document_size_);
 }
 
 uint32_t DocumentLoader::GetAvailableData() const {
   if (document_size_ == 0) {  // If document size is unknown.
     return current_pos_;
   }
 
-  std::vector<std::pair<size_t, size_t> > ranges;
+  std::vector<std::pair<size_t, size_t>> ranges;
   chunk_stream_.GetMissedRanges(0, document_size_, &ranges);
   uint32_t available = document_size_;
   for (const auto& range : ranges)
     available -= range.second;
   return available;
 }
 
 void DocumentLoader::ClearPendingRequests() {
-  pending_requests_.erase(pending_requests_.begin(),
-                          pending_requests_.end());
+  pending_requests_.erase(pending_requests_.begin(), pending_requests_.end());
 }
 
 bool DocumentLoader::GetBlock(uint32_t position,
                               uint32_t size,
                               void* buf) const {
   return chunk_stream_.ReadData(position, size, buf);
 }
 
 bool DocumentLoader::IsDataAvailable(uint32_t position, uint32_t size) const {
   return chunk_stream_.IsRangeAvailable(position, size);
@@ skipping 12 matching lines @@
   if (IsDocumentComplete())
     return;
 
   pending_requests_.push_back(std::pair<size_t, size_t>(position, size));
   DownloadPendingRequests();
 }
 
 void DocumentLoader::RemoveCompletedRanges() {
   // Split every request that has been partially downloaded already into smaller
   // requests.
-  std::vector<std::pair<size_t, size_t> > ranges;
+  std::vector<std::pair<size_t, size_t>> ranges;
   auto it = pending_requests_.begin();
   while (it != pending_requests_.end()) {
     chunk_stream_.GetMissedRanges(it->first, it->second, &ranges);
     pending_requests_.insert(it, ranges.begin(), ranges.end());
     ranges.clear();
     pending_requests_.erase(it++);
   }
 }
 
 void DocumentLoader::DownloadPendingRequests() {
@@ skipping 129 matching lines @@
     } else {
       partial_document_ = false;
     }
   }
 
   ReadMore();
 }
 
 void DocumentLoader::ReadMore() {
   pp::CompletionCallback callback =
-        loader_factory_.NewCallback(&DocumentLoader::DidRead);
+      loader_factory_.NewCallback(&DocumentLoader::DidRead);
   int rv = loader_.ReadResponseBody(buffer_, sizeof(buffer_), callback);
   if (rv != PP_OK_COMPLETIONPENDING)
     callback.Run(rv);
 }
 
 void DocumentLoader::DidRead(int32_t result) {
   if (result <= 0) {
     // If |result| == PP_OK, the document was loaded, otherwise an error was
     // encountered. Either way we want to stop processing the response. In the
     // case where an error occurred, the renderer will detect that we're missing
@@ skipping 78 matching lines @@
             current_request_offset_ + current_request_extended_size_) {
       loader_.Close();
     }
   }
 
   ReadMore();
 }
 
 bool DocumentLoader::SatisfyingRequest(size_t offset, size_t size) const {
   return offset <= current_pos_ + kDefaultRequestSize &&
-      current_pos_ < offset + size;
+         current_pos_ < offset + size;
 }
 
 void DocumentLoader::ReadComplete() {
   if (!partial_document_) {
     if (document_size_ == 0) {
       // For the document with no 'content-length" specified we've collected all
       // the chunks already. Let's allocate final document buffer and copy them
       // over.
       chunk_stream_.Preallocate(current_pos_);
       uint32_t pos = 0;
@@ skipping 21 matching lines @@
 
 void DocumentLoader::UpdateRendering() {
   if (header_request_)
     client_->OnPartialDocumentLoaded();
   else
     client_->OnPendingRequestComplete();
   header_request_ = false;
 }
 
 }  // namespace chrome_pdf