Use AttachmentUploadImpl instead of FakeAttachmentUploader.

chrome/browser/sync/profile_sync_components_factory_impl.cc

 // Copyright (c) 2012 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 "base/command_line.h"
 #include "build/build_config.h"
 #include "chrome/browser/bookmarks/bookmark_model_factory.h"
 #include "chrome/browser/bookmarks/enhanced_bookmarks_features.h"
 #include "chrome/browser/dom_distiller/dom_distiller_service_factory.h"
 #include "chrome/browser/history/history_service.h"
@@ skipping 42 matching lines @@
 #include "components/password_manager/core/browser/password_store.h"
 #include "components/signin/core/browser/signin_manager.h"
 #include "components/sync_driver/data_type_manager_impl.h"
 #include "components/sync_driver/data_type_manager_observer.h"
 #include "components/sync_driver/generic_change_processor.h"
 #include "components/sync_driver/proxy_data_type_controller.h"
 #include "components/sync_driver/shared_change_processor.h"
 #include "components/sync_driver/ui_data_type_controller.h"
 #include "content/public/browser/browser_thread.h"
 #include "extensions/browser/extension_system.h"
+#include "google_apis/gaia/oauth2_token_service_request.h"
+#include "net/url_request/url_request_context_getter.h"
 #include "sync/api/attachments/attachment_service.h"
 #include "sync/api/attachments/attachment_service_impl.h"
 #include "sync/api/syncable_service.h"
+#include "sync/internal_api/public/attachments/attachment_uploader_impl.h"
 #include "sync/internal_api/public/attachments/fake_attachment_downloader.h"
 #include "sync/internal_api/public/attachments/fake_attachment_store.h"
-#include "sync/internal_api/public/attachments/fake_attachment_uploader.h"
 
 #if defined(ENABLE_EXTENSIONS)
 #include "chrome/browser/extensions/api/storage/settings_sync_util.h"
 #include "chrome/browser/extensions/api/synced_notifications_private/synced_notifications_shim.h"
 #include "chrome/browser/extensions/extension_sync_service.h"
 #endif
 
 #if defined(ENABLE_APP_LIST)
 #include "chrome/browser/ui/app_list/app_list_syncable_service.h"
 #include "chrome/browser/ui/app_list/app_list_syncable_service_factory.h"
@@ skipping 35 matching lines @@
 using browser_sync::SyncBackendHost;
 using browser_sync::ThemeDataTypeController;
 using browser_sync::TypedUrlChangeProcessor;
 using browser_sync::TypedUrlDataTypeController;
 using browser_sync::TypedUrlModelAssociator;
 using browser_sync::UIDataTypeController;
 using content::BrowserThread;
 
 namespace {
 
+const char kAttachmentsPath[] = "/attachments/";
+
 syncer::ModelTypeSet GetDisabledTypesFromCommandLine(
     const CommandLine& command_line) {
   syncer::ModelTypeSet disabled_types;
   std::string disabled_types_str =
       command_line.GetSwitchValueASCII(switches::kDisableSyncTypes);
   disabled_types = syncer::ModelTypeSetFromString(disabled_types_str);
   return disabled_types;
 }
 
 syncer::ModelTypeSet GetEnabledTypesFromCommandLine(
     const CommandLine& command_line) {
   syncer::ModelTypeSet enabled_types;
   if (command_line.HasSwitch(switches::kEnableSyncSyncedNotifications)) {
     enabled_types.Put(syncer::SYNCED_NOTIFICATIONS);
   }
   return enabled_types;
 }
 
+// Returns the base URL for attachments.
+std::string GetSyncServiceAttachmentsURL(const GURL& sync_service_url) {
+  return sync_service_url.spec() + kAttachmentsPath;
+}
+
 }  // namespace
 
 ProfileSyncComponentsFactoryImpl::ProfileSyncComponentsFactoryImpl(
-    Profile* profile, CommandLine* command_line)
+    Profile* profile,
+    CommandLine* command_line,
+    const GURL& sync_service_url,
+    const std::string& account_id,
+    const OAuth2TokenService::ScopeSet& scope_set,
+    OAuth2TokenService* token_service,
+    net::URLRequestContextGetter* url_request_context_getter)
     : profile_(profile),
       command_line_(command_line),
       extension_system_(extensions::ExtensionSystem::Get(profile)),
-      web_data_service_(
-          WebDataServiceFactory::GetAutofillWebDataForProfile(
-              profile_, Profile::EXPLICIT_ACCESS)),
+      web_data_service_(WebDataServiceFactory::GetAutofillWebDataForProfile(
+          profile_, Profile::EXPLICIT_ACCESS)),
+      sync_service_url_(sync_service_url),
+      account_id_(account_id),
+      scope_set_(scope_set),
+      token_service_(token_service),
+      url_request_context_getter_(url_request_context_getter),
       weak_factory_(this) {
+  DCHECK(token_service_);
+  DCHECK(url_request_context_getter_);
 }
 
 ProfileSyncComponentsFactoryImpl::~ProfileSyncComponentsFactoryImpl() {
 }
 
 void ProfileSyncComponentsFactoryImpl::RegisterDataTypes(
     ProfileSyncService* pss) {
   syncer::ModelTypeSet disabled_types =
       GetDisabledTypesFromCommandLine(*command_line_);
   syncer::ModelTypeSet enabled_types =
@@ skipping 406 matching lines @@
     default:
       // The following datatypes still need to be transitioned to the
       // syncer::SyncableService API:
       // Bookmarks
       // Typed URLs
       NOTREACHED();
       return base::WeakPtr<syncer::SyncableService>();
   }
 }
 
+class TokenServiceProvider
+    : public OAuth2TokenServiceRequest::TokenServiceProvider {
+ public:
+  TokenServiceProvider(
+      const scoped_refptr<base::SingleThreadTaskRunner>& task_runner,
+      OAuth2TokenService* token_service);
+  virtual ~TokenServiceProvider();
+
+  // OAuth2TokenServiceRequest::TokenServiceProvider implementation.
+  virtual scoped_refptr<base::SingleThreadTaskRunner>
+      GetTokenServiceTaskRunner() OVERRIDE;
+  virtual OAuth2TokenService* GetTokenService() OVERRIDE;
+
+ private:
+  scoped_refptr<base::SingleThreadTaskRunner> task_runner_;
+  OAuth2TokenService* token_service_;
+};
+
+TokenServiceProvider::TokenServiceProvider(
+    const scoped_refptr<base::SingleThreadTaskRunner>& task_runner,
+    OAuth2TokenService* token_service)
+    : task_runner_(task_runner), token_service_(token_service) {
+}
+
+TokenServiceProvider::~TokenServiceProvider() {
+}
+
+scoped_refptr<base::SingleThreadTaskRunner>
+TokenServiceProvider::GetTokenServiceTaskRunner() {
+  return task_runner_;
+}
+
+OAuth2TokenService* TokenServiceProvider::GetTokenService() {
+  return token_service_;
+}
+
 scoped_ptr<syncer::AttachmentService>
 ProfileSyncComponentsFactoryImpl::CreateAttachmentService(
     syncer::AttachmentService::Delegate* delegate) {
-  // TODO(maniscalco): Use a shared (one per profile) thread-safe instances of
+  std::string url_prefix = GetSyncServiceAttachmentsURL(sync_service_url_);
+  scoped_ptr<OAuth2TokenServiceRequest::TokenServiceProvider>
+      token_service_provider(new TokenServiceProvider(
+          content::BrowserThread::GetMessageLoopProxyForThread(
+              content::BrowserThread::UI),
+          token_service_));
+
+  // TODO(maniscalco): Use shared (one per profile) thread-safe instances of
   // AttachmentUploader and AttachmentDownloader instead of creating a new one
   // per AttachmentService (bug 369536).
   scoped_ptr<syncer::AttachmentUploader> attachment_uploader(
-      new syncer::FakeAttachmentUploader);
+      new syncer::AttachmentUploaderImpl(url_prefix,
+                                         url_request_context_getter_,
+                                         account_id_,
+                                         scope_set_,
+                                         token_service_provider.Pass()));
+
   scoped_ptr<syncer::AttachmentDownloader> attachment_downloader(
       new syncer::FakeAttachmentDownloader());
 
   scoped_ptr<syncer::AttachmentStore> attachment_store(
       new syncer::FakeAttachmentStore(
           BrowserThread::GetMessageLoopProxyForThread(BrowserThread::FILE)));
 
   scoped_ptr<syncer::AttachmentService> attachment_service(
       new syncer::AttachmentServiceImpl(attachment_store.Pass(),
                                         attachment_uploader.Pass(),
@@ skipping 38 matching lines @@
       new TypedUrlModelAssociator(profile_sync_service,
                                   history_backend,
                                   error_handler);
   TypedUrlChangeProcessor* change_processor =
       new TypedUrlChangeProcessor(profile_,
                                   model_associator,
                                   history_backend,
                                   error_handler);
   return SyncComponents(model_associator, change_processor);
 }