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

components/sync/core_impl/attachments/attachment_uploader_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_uploader_impl.h"
+#include "components/sync/core/attachments/attachment_uploader_impl.h"
 
 #include <string>
 #include <utility>
 #include <vector>
 
 #include "base/bind.h"
 #include "base/callback.h"
 #include "base/location.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/ref_counted_memory.h"
 #include "base/message_loop/message_loop.h"
 #include "base/run_loop.h"
 #include "base/single_thread_task_runner.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/stringprintf.h"
 #include "base/synchronization/lock.h"
 #include "base/test/histogram_tester.h"
 #include "base/threading/non_thread_safe.h"
 #include "base/threading/thread.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_util.h"
+#include "components/sync/protocol/sync.pb.h"
 #include "google_apis/gaia/fake_oauth2_token_service.h"
 #include "google_apis/gaia/gaia_constants.h"
 #include "google_apis/gaia/oauth2_token_service_request.h"
 #include "net/http/http_status_code.h"
 #include "net/test/embedded_test_server/embedded_test_server.h"
 #include "net/test/embedded_test_server/http_request.h"
 #include "net/test/embedded_test_server/http_response.h"
 #include "net/url_request/url_request_test_util.h"
-#include "sync/api/attachments/attachment.h"
-#include "sync/internal_api/public/attachments/attachment_util.h"
-#include "sync/internal_api/public/base/model_type.h"
-#include "sync/protocol/sync.pb.h"
 #include "testing/gmock/include/gmock/gmock-matchers.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace {
 
 const char kAttachmentData[] = "some data";
 const char kAccountId[] = "some-account-id";
 const char kAccessToken[] = "some-access-token";
 const char kContentTypeValue[] = "application/octet-stream";
 const char kXGoogHash[] = "X-Goog-Hash";
@@ skipping 57 matching lines @@
   std::string response_access_token_;
   base::Time response_expiration_;
   int num_invalidate_token_;
   std::string last_token_invalidated_;
 };
 
 MockOAuth2TokenService::MockOAuth2TokenService()
     : response_error_(GoogleServiceAuthError::AuthErrorNone()),
       response_access_token_(kAccessToken),
       response_expiration_(base::Time::Max()),
-      num_invalidate_token_(0) {
-}
+      num_invalidate_token_(0) {}
 
-MockOAuth2TokenService::~MockOAuth2TokenService() {
-}
+MockOAuth2TokenService::~MockOAuth2TokenService() {}
 
 void MockOAuth2TokenService::SetResponse(const GoogleServiceAuthError& error,
                                          const std::string& access_token,
                                          const base::Time& expiration) {
   response_error_ = error;
   response_access_token_ = access_token;
   response_expiration_ = expiration;
 }
 
 void MockOAuth2TokenService::FetchOAuth2Token(
@@ skipping 35 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_;
 }
@@ skipping 75 matching lines @@
  private:
   // Protects status_code_.
   mutable base::Lock mutex_;
   net::HttpStatusCode status_code_;
 
   scoped_refptr<base::SingleThreadTaskRunner> test_task_runner_;
   base::WeakPtr<AttachmentUploaderImplTest> test_;
 };
 
 AttachmentUploaderImplTest::AttachmentUploaderImplTest()
-    : weak_ptr_factory_(this) {
-}
+    : weak_ptr_factory_(this) {}
 
 void AttachmentUploaderImplTest::OnRequestReceived(const HttpRequest& request) {
   DCHECK(CalledOnValidThread());
   http_requests_received_.push_back(request);
 }
 
 void AttachmentUploaderImplTest::SetUp() {
   DCHECK(CalledOnValidThread());
   request_handler_.reset(new RequestHandler(message_loop_.task_runner(),
                                             weak_ptr_factory_.GetWeakPtr()));
@@ skipping 56 matching lines @@
 
 std::vector<HttpRequest>& AttachmentUploaderImplTest::http_requests_received() {
   return http_requests_received_;
 }
 
 std::vector<AttachmentUploader::UploadResult>&
 AttachmentUploaderImplTest::upload_results() {
   return upload_results_;
 }
 
-std::vector<AttachmentId>&
-AttachmentUploaderImplTest::attachment_ids() {
+std::vector<AttachmentId>& AttachmentUploaderImplTest::attachment_ids() {
   return attachment_ids_;
 }
 
 MockOAuth2TokenService& AttachmentUploaderImplTest::token_service() {
   return *token_service_;
 }
 
 base::MessageLoopForIO& AttachmentUploaderImplTest::message_loop() {
   return message_loop_;
 }
@@ skipping 22 matching lines @@
 }
 
 RequestHandler::~RequestHandler() {
   DetachFromThread();
 }
 
 std::unique_ptr<HttpResponse> RequestHandler::HandleRequest(
     const HttpRequest& request) {
   DCHECK(CalledOnValidThread());
   test_task_runner_->PostTask(
-      FROM_HERE,
-      base::Bind(
-          &AttachmentUploaderImplTest::OnRequestReceived, test_, request));
+      FROM_HERE, base::Bind(&AttachmentUploaderImplTest::OnRequestReceived,
+                            test_, request));
   std::unique_ptr<BasicHttpResponse> response(new BasicHttpResponse);
   response->set_code(GetStatusCode());
   response->set_content_type("text/plain");
   return std::move(response);
 }
 
 void RequestHandler::SetStatusCode(const net::HttpStatusCode& status_code) {
   base::AutoLock lock(mutex_);
   status_code_ = status_code;
 }
@@ skipping 266 matching lines @@
   scoped_refptr<base::RefCountedString> hello_world(new base::RefCountedString);
   hello_world->data() = "hello world";
   EXPECT_EQ("yZRlqg==", AttachmentUploaderImpl::FormatCrc32cHash(
                             ComputeCrc32c(hello_world)));
 }
 
 // TODO(maniscalco): Add test case for when we are uploading an attachment that
 // already exists.  409 Conflict? (bug 379825)
 
 }  // namespace syncer