[Sync] Move //sync to //components/sync.

components/sync/core_impl/attachments/attachment_uploader_impl.cc

 // Copyright 2014 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 "sync/internal_api/public/attachments/attachment_uploader_impl.h"
+#include "components/sync/core/attachments/attachment_uploader_impl.h"
 
 #include <stdint.h>
+
 #include <string>
 #include <utility>
 #include <vector>
 
 #include "base/base64.h"
 #include "base/base64url.h"
 #include "base/bind.h"
 #include "base/location.h"
 #include "base/macros.h"
 #include "base/memory/weak_ptr.h"
 #include "base/metrics/sparse_histogram.h"
 #include "base/single_thread_task_runner.h"
 #include "base/strings/string_piece.h"
 #include "base/strings/stringprintf.h"
 #include "base/sys_byteorder.h"
 #include "base/threading/non_thread_safe.h"
 #include "base/threading/thread_task_runner_handle.h"
+#include "components/sync/api/attachments/attachment.h"
+#include "components/sync/protocol/sync.pb.h"
 #include "google_apis/gaia/gaia_constants.h"
 #include "net/base/load_flags.h"
 #include "net/http/http_status_code.h"
 #include "net/url_request/url_fetcher.h"
 #include "net/url_request/url_fetcher_delegate.h"
 #include "net/url_request/url_request_status.h"
-#include "sync/api/attachments/attachment.h"
-#include "sync/protocol/sync.pb.h"
 
 namespace {
 
 const char kContentType[] = "application/octet-stream";
 const char kAttachments[] = "attachments/";
 const char kSyncStoreBirthday[] = "X-Sync-Store-Birthday";
 const char kSyncDataTypeId[] = "X-Sync-Data-Type-Id";
 
 }  // namespace
 
@@ skipping 105 matching lines @@
       model_type_(model_type) {
   DCHECK(upload_url_.is_valid());
   DCHECK(url_request_context_getter_.get());
   DCHECK(!account_id_.empty());
   DCHECK(!scopes_.empty());
   DCHECK(token_service_provider_);
   DCHECK(!raw_store_birthday_.empty());
   GetToken();
 }
 
-AttachmentUploaderImpl::UploadState::~UploadState() {
-}
+AttachmentUploaderImpl::UploadState::~UploadState() {}
 
 bool AttachmentUploaderImpl::UploadState::IsStopped() const {
   DCHECK(CalledOnValidThread());
   return is_stopped_;
 }
 
 void AttachmentUploaderImpl::UploadState::AddUserCallback(
     const UploadCallback& user_callback) {
   DCHECK(CalledOnValidThread());
   DCHECK(!is_stopped_);
   user_callbacks_.push_back(user_callback);
 }
 
 const Attachment& AttachmentUploaderImpl::UploadState::GetAttachment() {
   DCHECK(CalledOnValidThread());
   return attachment_;
 }
 
 void AttachmentUploaderImpl::UploadState::OnURLFetchComplete(
     const net::URLFetcher* source) {
   DCHECK(CalledOnValidThread());
   if (is_stopped_) {
     return;
   }
 
   UploadResult result = UPLOAD_TRANSIENT_ERROR;
   AttachmentId attachment_id = attachment_.GetId();
   net::URLRequestStatus status = source->GetStatus();
   const int response_code = source->GetResponseCode();
-  UMA_HISTOGRAM_SPARSE_SLOWLY("Sync.Attachments.UploadResponseCode",
+  UMA_HISTOGRAM_SPARSE_SLOWLY(
+      "Sync.Attachments.UploadResponseCode",
       status.is_success() ? response_code : status.error());
   if (response_code == net::HTTP_OK) {
     result = UPLOAD_SUCCESS;
   } else if (response_code == net::HTTP_UNAUTHORIZED) {
     // Server tells us we've got a bad token so invalidate it.
     OAuth2TokenServiceRequest::InvalidateToken(
         token_service_provider_, account_id_, scopes_, access_token_);
     // Fail the request, but indicate that it may be successful if retried.
     result = UPLOAD_TRANSIENT_ERROR;
   } else if (response_code == net::HTTP_FORBIDDEN) {
@@ skipping 107 matching lines @@
                                               const UploadCallback& callback) {
   DCHECK(CalledOnValidThread());
   const AttachmentId attachment_id = attachment.GetId();
   const std::string unique_id = attachment_id.GetProto().unique_id();
   DCHECK(!unique_id.empty());
   StateMap::iterator iter = state_map_.find(unique_id);
   if (iter != state_map_.end()) {
     // We have an old upload request for this attachment...
     if (!iter->second->IsStopped()) {
       // "join" to it.
-      DCHECK(attachment.GetData()
-                 ->Equals(iter->second->GetAttachment().GetData()));
+      DCHECK(attachment.GetData()->Equals(
+          iter->second->GetAttachment().GetData()));
       iter->second->AddUserCallback(callback);
       return;
     } else {
       // It's stopped so we can't use it.  Delete it.
       state_map_.erase(iter);
     }
   }
 
   const GURL url = GetURLForAttachmentId(sync_service_url_, attachment_id);
   std::unique_ptr<UploadState> upload_state(new UploadState(
@@ skipping 25 matching lines @@
   // stopped, but before this method was invoked.  In that case the UploadState
   // in the map might be a new one.
   if (iter != state_map_.end() && iter->second->IsStopped()) {
     state_map_.erase(iter);
   }
 }
 
 std::string AttachmentUploaderImpl::FormatCrc32cHash(uint32_t crc32c) {
   const uint32_t crc32c_big_endian = base::HostToNet32(crc32c);
   const base::StringPiece raw(reinterpret_cast<const char*>(&crc32c_big_endian),
-                        sizeof(crc32c_big_endian));
+                              sizeof(crc32c_big_endian));
   std::string encoded;
   base::Base64Encode(raw, &encoded);
   return encoded;
 }
 
 void AttachmentUploaderImpl::ConfigureURLFetcherCommon(
     net::URLFetcher* fetcher,
     const std::string& access_token,
     const std::string& raw_store_birthday,
     ModelType model_type,
     net::URLRequestContextGetter* request_context_getter) {
   DCHECK(request_context_getter);
   DCHECK(fetcher);
   fetcher->SetAutomaticallyRetryOn5xx(false);
   fetcher->SetRequestContext(request_context_getter);
   fetcher->SetLoadFlags(net::LOAD_DO_NOT_SAVE_COOKIES |
                         net::LOAD_DO_NOT_SEND_COOKIES |
                         net::LOAD_DISABLE_CACHE);
   fetcher->AddExtraRequestHeader(base::StringPrintf(
       "%s: Bearer %s", net::HttpRequestHeaders::kAuthorization,
       access_token.c_str()));
   // Encode the birthday.  Birthday is opaque so we assume it could contain
   // anything.  Encode it so that it's safe to pass as an HTTP header value.
   std::string encoded_store_birthday;
-  base::Base64UrlEncode(
-      raw_store_birthday, base::Base64UrlEncodePolicy::OMIT_PADDING,
-      &encoded_store_birthday);
+  base::Base64UrlEncode(raw_store_birthday,
+                        base::Base64UrlEncodePolicy::OMIT_PADDING,
+                        &encoded_store_birthday);
   fetcher->AddExtraRequestHeader(base::StringPrintf(
       "%s: %s", kSyncStoreBirthday, encoded_store_birthday.c_str()));
 
   // Use field number to pass ModelType because it's stable and we have server
   // code to decode it.
   const int field_number = GetSpecificsFieldNumberFromModelType(model_type);
   fetcher->AddExtraRequestHeader(
       base::StringPrintf("%s: %d", kSyncDataTypeId, field_number));
 }
 
 }  // namespace syncer