Replace PO2TS::GetPrimaryAccountId() with SMB::GetAuthenticatedAccountId.

chrome/browser/sync_file_system/drive_backend_v1/api_util.cc

 // Copyright 2013 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 "chrome/browser/sync_file_system/drive_backend_v1/api_util.h"
 
 #include <algorithm>
 #include <functional>
 #include <sstream>
 #include <string>
 
 #include "base/file_util.h"
 #include "base/sequenced_task_runner.h"
 #include "base/strings/string_util.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/threading/sequenced_worker_pool.h"
 #include "base/values.h"
 #include "chrome/browser/drive/drive_api_service.h"
 #include "chrome/browser/drive/drive_api_util.h"
 #include "chrome/browser/drive/drive_uploader.h"
 #include "chrome/browser/drive/gdata_wapi_service.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/signin/profile_oauth2_token_service.h"
 #include "chrome/browser/signin/profile_oauth2_token_service_factory.h"
+#include "chrome/browser/signin/signin_manager.h"
+#include "chrome/browser/signin/signin_manager_factory.h"
 #include "chrome/browser/sync_file_system/drive_backend/drive_backend_constants.h"
 #include "chrome/browser/sync_file_system/drive_backend_v1/drive_file_sync_util.h"
 #include "chrome/browser/sync_file_system/logger.h"
 #include "chrome/browser/sync_file_system/syncable_file_system_util.h"
 #include "content/public/browser/browser_thread.h"
 #include "extensions/common/constants.h"
 #include "extensions/common/extension.h"
 #include "google_apis/drive/drive_api_parser.h"
 #include "google_apis/drive/drive_api_url_generator.h"
 #include "google_apis/drive/gdata_wapi_url_generator.h"
@@ skipping 115 matching lines @@
                               webkit_blob::ScopedFile::DELETE_ON_SCOPE_OUT,
                               base::MessageLoopProxy::current().get());
   return success;
 }
 
 }  // namespace
 
 APIUtil::APIUtil(Profile* profile,
                  const base::FilePath& temp_dir_path)
     : oauth_service_(ProfileOAuth2TokenServiceFactory::GetForProfile(profile)),
+      signin_manager_(SigninManagerFactory::GetForProfile(profile)),
       upload_next_key_(0),
       temp_dir_path_(temp_dir_path),
       has_initialized_token_(false) {
   base::SequencedWorkerPool* blocking_pool =
       content::BrowserThread::GetBlockingPool();
   scoped_refptr<base::SequencedTaskRunner> task_runner(
       blocking_pool->GetSequencedTaskRunner(blocking_pool->GetSequenceToken()));
   if (IsDriveAPIDisabled()) {
     drive_service_.reset(new drive::GDataWapiService(
         oauth_service_,
         profile->GetRequestContext(),
         task_runner.get(),
         GURL(google_apis::GDataWapiUrlGenerator::kBaseUrlForProduction),
         GURL(google_apis::GDataWapiUrlGenerator::kBaseDownloadUrlForProduction),
         std::string() /* custom_user_agent */));
   } else {
     drive_service_.reset(new drive::DriveAPIService(
         oauth_service_,
         profile->GetRequestContext(),
         task_runner.get(),
         GURL(google_apis::DriveApiUrlGenerator::kBaseUrlForProduction),
         GURL(google_apis::DriveApiUrlGenerator::kBaseDownloadUrlForProduction),
         GURL(google_apis::GDataWapiUrlGenerator::kBaseUrlForProduction),
         std::string() /* custom_user_agent */));
   }
 
-  drive_service_->Initialize(oauth_service_->GetPrimaryAccountId());
+  drive_service_->Initialize(signin_manager_->GetAuthenticatedAccountId());
   drive_service_->AddObserver(this);
   has_initialized_token_ = drive_service_->HasRefreshToken();
 
   net::NetworkChangeNotifier::AddConnectionTypeObserver(this);
 
   drive_uploader_.reset(new drive::DriveUploader(
       drive_service_.get(), content::BrowserThread::GetBlockingPool()));
 }
 
 scoped_ptr<APIUtil> APIUtil::CreateForTesting(
@@ skipping 459 matching lines @@
 }
 
 // static
 GURL APIUtil::DirectoryTitleToOrigin(const std::string& title) {
   return extensions::Extension::GetBaseURLFromExtensionId(title);
 }
 
 void APIUtil::OnReadyToSendRequests() {
   DCHECK(CalledOnValidThread());
   if (!has_initialized_token_) {
-    drive_service_->Initialize(oauth_service_->GetPrimaryAccountId());
+    drive_service_->Initialize(signin_manager_->GetAuthenticatedAccountId());
     has_initialized_token_ = true;
   }
   FOR_EACH_OBSERVER(APIUtilObserver, observers_, OnAuthenticated());
 }
 
 void APIUtil::OnConnectionTypeChanged(
     net::NetworkChangeNotifier::ConnectionType type) {
   DCHECK(CalledOnValidThread());
   if (type != net::NetworkChangeNotifier::CONNECTION_NONE) {
     FOR_EACH_OBSERVER(APIUtilObserver, observers_, OnNetworkConnected());
@@ skipping 454 matching lines @@
 }
 
 std::string APIUtil::GetRootResourceId() const {
   if (IsDriveAPIDisabled())
     return drive_service_->GetRootResourceId();
   return root_resource_id_;
 }
 
 }  // namespace drive_backend
 }  // namespace sync_file_system