[Sync] //components/sync internal changes [DO NOT SUBMIT]

components/sync/core_impl/attachments/attachment_downloader_impl_unittest.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_downloader_impl.h"
+#include "components/sync/core/attachments/attachment_downloader_impl.h"
 
 #include <stdint.h>
 
 #include <map>
 
 #include "base/bind.h"
 #include "base/location.h"
 #include "base/memory/weak_ptr.h"
 #include "base/message_loop/message_loop.h"
 #include "base/run_loop.h"
 #include "base/single_thread_task_runner.h"
 #include "base/test/histogram_tester.h"
 #include "base/threading/thread_task_runner_handle.h"
+#include "components/sync/api/attachments/attachment.h"
+#include "components/sync/base/model_type.h"
+#include "components/sync/core/attachments/attachment_uploader_impl.h"
+#include "components/sync/core/attachments/attachment_util.h"
 #include "google_apis/gaia/fake_oauth2_token_service.h"
 #include "google_apis/gaia/gaia_constants.h"
 #include "net/http/http_response_headers.h"
 #include "net/url_request/test_url_fetcher_factory.h"
 #include "net/url_request/url_request_test_util.h"
-#include "sync/api/attachments/attachment.h"
-#include "sync/internal_api/public/attachments/attachment_uploader_impl.h"
-#include "sync/internal_api/public/attachments/attachment_util.h"
-#include "sync/internal_api/public/base/model_type.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "third_party/leveldatabase/src/util/crc32c.h"
 
 namespace syncer {
 
 namespace {
 
 const char kAccountId[] = "attachments@gmail.com";
 const char kAccessToken[] = "access.token";
 const char kAttachmentServerUrl[] = "http://attachments.com/";
@@ skipping 84 matching lines @@
   scoped_refptr<base::SingleThreadTaskRunner> task_runner_;
   OAuth2TokenService* token_service_;
 };
 
 TokenServiceProvider::TokenServiceProvider(OAuth2TokenService* token_service)
     : task_runner_(base::ThreadTaskRunnerHandle::Get()),
       token_service_(token_service) {
   DCHECK(token_service_);
 }
 
-TokenServiceProvider::~TokenServiceProvider() {
-}
+TokenServiceProvider::~TokenServiceProvider() {}
 
 scoped_refptr<base::SingleThreadTaskRunner>
 TokenServiceProvider::GetTokenServiceTaskRunner() {
   return task_runner_;
 }
 
 OAuth2TokenService* TokenServiceProvider::GetTokenService() {
   DCHECK(task_runner_->BelongsToCurrentThread());
   return token_service_;
 }
 
 }  // namespace
 
 class AttachmentDownloaderImplTest : public testing::Test {
  protected:
   typedef std::map<AttachmentId, AttachmentDownloader::DownloadResult>
       ResultsMap;
 
   enum HashHeaderType {
     HASH_HEADER_NONE,
     HASH_HEADER_VALID,
     HASH_HEADER_INVALID
   };
 
   AttachmentDownloaderImplTest()
       : num_completed_downloads_(0),
-        attachment_id_(
-            Attachment::Create(new base::RefCountedStaticMemory(
-                                   kAttachmentContent,
-                                   strlen(kAttachmentContent))).GetId()) {}
+        attachment_id_(Attachment::Create(new base::RefCountedStaticMemory(
+                                              kAttachmentContent,
+                                              strlen(kAttachmentContent)))
+                           .GetId()) {}
 
   void SetUp() override;
   void TearDown() override;
 
   AttachmentDownloader* downloader() { return attachment_downloader_.get(); }
 
   MockOAuth2TokenService* token_service() { return token_service_.get(); }
 
   int num_completed_downloads() { return num_completed_downloads_; }
 
   const AttachmentId attachment_id() const { return attachment_id_; }
 
   AttachmentDownloader::DownloadCallback download_callback(
       const AttachmentId& id) {
     return base::Bind(&AttachmentDownloaderImplTest::DownloadDone,
-                      base::Unretained(this),
-                      id);
+                      base::Unretained(this), id);
   }
 
   // Respond with |response_code| and hash header of type |hash_header_type|.
   void CompleteDownload(int response_code, HashHeaderType hash_header_type);
 
   void DownloadDone(const AttachmentId& attachment_id,
                     const AttachmentDownloader::DownloadResult& result,
                     std::unique_ptr<Attachment> attachment);
 
   void VerifyDownloadResult(const AttachmentId& attachment_id,
@@ skipping 263 matching lines @@
   AttachmentId id1 = AttachmentId::Create(attachment_id().GetSize(), 12345);
   downloader()->DownloadAttachment(id1, download_callback(id1));
   RunMessageLoop();
   token_service()->RespondToAccessTokenRequest(
       GoogleServiceAuthError::AuthErrorNone());
   RunMessageLoop();
   CompleteDownload(net::HTTP_OK, HASH_HEADER_VALID);
   VerifyDownloadResult(id1, AttachmentDownloader::DOWNLOAD_UNSPECIFIED_ERROR);
 }
 
-
 // Verify that extract fails when there is no headers object.
 TEST_F(AttachmentDownloaderImplTest, ExtractCrc32c_NoHeaders) {
   uint32_t extracted;
   ASSERT_FALSE(AttachmentDownloaderImpl::ExtractCrc32c(nullptr, &extracted));
 }
 
 // Verify that extract fails when there is no crc32c value.
 TEST_F(AttachmentDownloaderImplTest, ExtractCrc32c_Empty) {
   std::string raw;
   raw += "HTTP/1.1 200 OK\n";
@@ skipping 56 matching lines @@
   raw += "\n";
   std::replace(raw.begin(), raw.end(), '\n', '\0');
   scoped_refptr<net::HttpResponseHeaders> headers(
       new net::HttpResponseHeaders(raw));
   uint32_t extracted;
   ASSERT_FALSE(
       AttachmentDownloaderImpl::ExtractCrc32c(headers.get(), &extracted));
 }
 
 }  // namespace syncer