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

components/sync/core_impl/attachments/attachment_service_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_service_impl.h"
+#include "components/sync/core/attachments/attachment_service_impl.h"
 
 #include <iterator>
 #include <utility>
 
 #include "base/bind.h"
 #include "base/location.h"
 #include "base/macros.h"
 #include "base/single_thread_task_runner.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "base/time/time.h"
-#include "sync/api/attachments/attachment.h"
-#include "sync/internal_api/public/attachments/fake_attachment_downloader.h"
-#include "sync/internal_api/public/attachments/fake_attachment_uploader.h"
+#include "components/sync/api/attachments/attachment.h"
+#include "components/sync/core/attachments/fake_attachment_downloader.h"
+#include "components/sync/core/attachments/fake_attachment_uploader.h"
 
 namespace syncer {
 
 // GetOrDownloadAttachments starts multiple parallel DownloadAttachment calls.
 // GetOrDownloadState tracks completion of these calls and posts callback for
 // consumer once all attachments are either retrieved or reported unavailable.
 class AttachmentServiceImpl::GetOrDownloadState
     : public base::RefCounted<GetOrDownloadState>,
       public base::NonThreadSafe {
  public:
@@ skipping 29 matching lines @@
   std::unique_ptr<AttachmentMap> retrieved_attachments_;
 
   DISALLOW_COPY_AND_ASSIGN(GetOrDownloadState);
 };
 
 AttachmentServiceImpl::GetOrDownloadState::GetOrDownloadState(
     const AttachmentIdList& attachment_ids,
     const GetOrDownloadCallback& callback)
     : callback_(callback), retrieved_attachments_(new AttachmentMap()) {
   std::copy(
-      attachment_ids.begin(),
-      attachment_ids.end(),
+      attachment_ids.begin(), attachment_ids.end(),
       std::inserter(in_progress_attachments_, in_progress_attachments_.end()));
   PostResultIfAllRequestsCompleted();
 }
 
 AttachmentServiceImpl::GetOrDownloadState::~GetOrDownloadState() {
   DCHECK(CalledOnValidThread());
 }
 
 void AttachmentServiceImpl::GetOrDownloadState::AddAttachment(
     const Attachment& attachment) {
@@ skipping 13 matching lines @@
   DCHECK(CalledOnValidThread());
   DCHECK(unavailable_attachments_.find(attachment_id) ==
          unavailable_attachments_.end());
   unavailable_attachments_.insert(attachment_id);
   DCHECK(in_progress_attachments_.find(attachment_id) !=
          in_progress_attachments_.end());
   in_progress_attachments_.erase(attachment_id);
   PostResultIfAllRequestsCompleted();
 }
 
-void
-AttachmentServiceImpl::GetOrDownloadState::PostResultIfAllRequestsCompleted() {
+void AttachmentServiceImpl::GetOrDownloadState::
+    PostResultIfAllRequestsCompleted() {
   if (in_progress_attachments_.empty()) {
     // All requests completed. Let's notify consumer.
     GetOrDownloadResult result =
         unavailable_attachments_.empty() ? GET_SUCCESS : GET_UNSPECIFIED_ERROR;
     base::ThreadTaskRunnerHandle::Get()->PostTask(
         FROM_HERE,
         base::Bind(callback_, result, base::Passed(&retrieved_attachments_)));
   }
 }
 
@@ skipping 12 matching lines @@
   DCHECK(CalledOnValidThread());
   DCHECK(attachment_store_.get());
 
   // TODO(maniscalco): Observe network connectivity change events.  When the
   // network becomes disconnected, consider suspending queue dispatch.  When
   // connectivity is restored, consider clearing any dispatch backoff (bug
   // 411981).
   upload_task_queue_.reset(new TaskQueue<AttachmentId>(
       base::Bind(&AttachmentServiceImpl::BeginUpload,
                  weak_ptr_factory_.GetWeakPtr()),
-      initial_backoff_delay,
-      max_backoff_delay));
+      initial_backoff_delay, max_backoff_delay));
 
   net::NetworkChangeNotifier::AddNetworkChangeObserver(this);
 }
 
 AttachmentServiceImpl::~AttachmentServiceImpl() {
   DCHECK(CalledOnValidThread());
   net::NetworkChangeNotifier::RemoveNetworkChangeObserver(this);
 }
 
 // Static.
@@ skipping 28 matching lines @@
                                      weak_ptr_factory_.GetWeakPtr(), state));
 }
 
 void AttachmentServiceImpl::ReadDone(
     const scoped_refptr<GetOrDownloadState>& state,
     const AttachmentStore::Result& result,
     std::unique_ptr<AttachmentMap> attachments,
     std::unique_ptr<AttachmentIdList> unavailable_attachment_ids) {
   // Add read attachments to result.
   for (AttachmentMap::const_iterator iter = attachments->begin();
-       iter != attachments->end();
-       ++iter) {
+       iter != attachments->end(); ++iter) {
     state->AddAttachment(iter->second);
   }
 
   AttachmentIdList::const_iterator iter = unavailable_attachment_ids->begin();
   AttachmentIdList::const_iterator end = unavailable_attachment_ids->end();
   if (result != AttachmentStore::STORE_INITIALIZATION_FAILED &&
       attachment_downloader_.get()) {
     // Try to download locally unavailable attachments.
     for (; iter != end; ++iter) {
       attachment_downloader_->DownloadAttachment(
-          *iter,
-          base::Bind(&AttachmentServiceImpl::DownloadDone,
-                     weak_ptr_factory_.GetWeakPtr(),
-                     state,
-                     *iter));
+          *iter, base::Bind(&AttachmentServiceImpl::DownloadDone,
+                            weak_ptr_factory_.GetWeakPtr(), state, *iter));
     }
   } else {
     // No downloader so all locally unavailable attachments are unavailable.
     for (; iter != end; ++iter) {
       state->AddUnavailableAttachmentId(*iter);
     }
   }
 }
 
 void AttachmentServiceImpl::WriteDone(
@@ skipping 102 matching lines @@
     for (; iter != end; ++iter) {
       upload_task_queue_->Cancel(*iter);
     }
     attachment_store_->DropSyncReference(*unavailable_attachment_ids);
   }
 
   AttachmentMap::const_iterator iter = attachments->begin();
   AttachmentMap::const_iterator end = attachments->end();
   for (; iter != end; ++iter) {
     attachment_uploader_->UploadAttachment(
-        iter->second,
-        base::Bind(&AttachmentServiceImpl::UploadDone,
-                   weak_ptr_factory_.GetWeakPtr()));
+        iter->second, base::Bind(&AttachmentServiceImpl::UploadDone,
+                                 weak_ptr_factory_.GetWeakPtr()));
   }
 }
 
 void AttachmentServiceImpl::SetTimerForTest(
     std::unique_ptr<base::Timer> timer) {
   upload_task_queue_->SetTimerForTest(std::move(timer));
 }
 
 }  // namespace syncer