[Sync] Fix namespaces for the browser_sync component.

chrome/browser/ui/webui/settings/people_handler_unittest.cc

 // Copyright 2015 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/ui/webui/settings/people_handler.h"
 
 #include <memory>
 #include <string>
 #include <vector>
 
@@ skipping 183 matching lines @@
         "Person 1", nullptr, base::UTF8ToUTF16("Person 1"), 0, std::string(),
         testing_factories);
 
     // Sign in the user.
     mock_signin_ = static_cast<SigninManagerBase*>(
         SigninManagerFactory::GetForProfile(profile_));
     std::string username = GetTestUser();
     if (!username.empty())
       mock_signin_->SetAuthenticatedAccountInfo(username, username);
 
-    mock_pss_ = static_cast<ProfileSyncServiceMock*>(
+    mock_pss_ = static_cast<browser_sync::ProfileSyncServiceMock*>(

[skym, 2016/09/22 17:25:59]

Again, unittest, using?

[maxbogue, 2016/09/22 19:41:15]

Done.

         ProfileSyncServiceFactory::GetInstance()->SetTestingFactoryAndUse(
             profile_, BuildMockProfileSyncService));
     EXPECT_CALL(*mock_pss_, GetAuthError()).WillRepeatedly(ReturnRef(error_));
     ON_CALL(*mock_pss_, GetPassphraseType())
         .WillByDefault(Return(syncer::PassphraseType::IMPLICIT_PASSPHRASE));
     ON_CALL(*mock_pss_, GetExplicitPassphraseTime()).WillByDefault(
         Return(base::Time()));
     ON_CALL(*mock_pss_, GetRegisteredDataTypes())
         .WillByDefault(Return(syncer::ModelTypeSet()));
 
@@ skipping 82 matching lines @@
       handler_->sync_startup_tracker_->OnStateChanged();
   }
 
   virtual std::string GetTestUser() {
     return std::string(kTestUser);
   }
 
   content::TestBrowserThreadBundle thread_bundle_;
   std::unique_ptr<TestingProfileManager> profile_manager_;
   Profile* profile_;
-  ProfileSyncServiceMock* mock_pss_;
+  browser_sync::ProfileSyncServiceMock* mock_pss_;
   GoogleServiceAuthError error_;
   SigninManagerBase* mock_signin_;
   content::TestWebUI web_ui_;
   std::unique_ptr<TestingPeopleHandler> handler_;
 };
 
 class PeopleHandlerFirstSigninTest : public PeopleHandlerTest {
   std::string GetTestUser() override { return std::string(); }
 };
 
@@ skipping 118 matching lines @@
   error_ = GoogleServiceAuthError::AuthErrorNone();
   EXPECT_CALL(*mock_pss_, IsBackendInitialized())
       .WillOnce(Return(false))
       .WillRepeatedly(Return(true));
   SetDefaultExpectationsForConfigPage();
   handler_->OpenSyncSetup(false /* creating_supervised_user */);
 
   // It's important to tell sync the user cancelled the setup flow before we
   // tell it we're through with the setup progress.
   testing::InSequence seq;
-  EXPECT_CALL(*mock_pss_, RequestStop(ProfileSyncService::CLEAR_DATA));
+  EXPECT_CALL(*mock_pss_,
+              RequestStop(browser_sync::ProfileSyncService::CLEAR_DATA));
   EXPECT_CALL(*mock_pss_, OnSetupInProgressHandleDestroyed());
 
   handler_->CloseSyncSetup();
   EXPECT_EQ(NULL,
             LoginUIServiceFactory::GetForProfile(
                 profile_)->current_login_ui());
 }
 
 TEST_F(PeopleHandlerTest,
        DisplayConfigureWithBackendDisabledAndSigninFailed) {
@@ skipping 123 matching lines @@
   base::ListValue list_args;
   list_args.AppendString(kTestCallbackId);
   list_args.AppendString(args);
   EXPECT_CALL(*mock_pss_, IsPassphraseRequiredForDecryption())
       .WillRepeatedly(Return(false));
   EXPECT_CALL(*mock_pss_, IsPassphraseRequired())
       .WillRepeatedly(Return(false));
   EXPECT_CALL(*mock_pss_, IsUsingSecondaryPassphrase())
       .WillRepeatedly(Return(false));
   SetupInitializedProfileSyncService();
-  EXPECT_CALL(*mock_pss_,
-              SetEncryptionPassphrase("custom_passphrase",
-                                      ProfileSyncService::EXPLICIT));
+  EXPECT_CALL(*mock_pss_, SetEncryptionPassphrase(
+                              "custom_passphrase",
+                              browser_sync::ProfileSyncService::EXPLICIT));
 
   handler_->HandleSetEncryption(&list_args);
   ExpectPageStatusResponse(PeopleHandler::kConfigurePageStatus);
 }
 
 TEST_F(PeopleHandlerTest, EnterWrongExistingPassphrase) {
   base::DictionaryValue dict;
   dict.SetBoolean("setNewPassphrase", false);
   std::string args = GetConfiguration(&dict, SYNC_ALL_DATA, GetAllTypes(),
                                       "invalid_passphrase", ENCRYPT_ALL_DATA);
@@ skipping 305 matching lines @@
   SetupInitializedProfileSyncService();
   EXPECT_CALL(*mock_pss_, IsEncryptEverythingAllowed())
       .WillRepeatedly(Return(false));
   EXPECT_CALL(*mock_pss_, EnableEncryptEverything()).Times(0);
   handler_->HandleSetEncryption(&list_args);
 
   ExpectPageStatusResponse(PeopleHandler::kConfigurePageStatus);
 }
 
 }  // namespace settings