Do not display lock for hosted domains

chrome/browser/profiles/gaia_info_update_service_unittest.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 "chrome/browser/profiles/gaia_info_update_service.h"
 
 #include "base/prefs/pref_service.h"
 #include "base/strings/utf_string_conversions.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/prefs/pref_service_syncable.h"
 #include "chrome/browser/profiles/profile_downloader.h"
 #include "chrome/browser/profiles/profile_info_cache.h"
 #include "chrome/browser/profiles/profile_info_cache_unittest.h"
+#include "chrome/browser/profiles/profiles_state.h"
 #include "chrome/browser/signin/chrome_signin_client_factory.h"
 #include "chrome/browser/signin/signin_manager_factory.h"
 #include "chrome/browser/signin/test_signin_client_builder.h"
 #include "chrome/common/pref_names.h"
 #include "chrome/test/base/testing_browser_process.h"
 #include "chrome/test/base/testing_profile.h"
 #include "chrome/test/base/testing_profile_manager.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "ui/gfx/image/image.h"
 #include "ui/gfx/image/image_unittest_util.h"
@@ skipping 11 matching lines @@
 
   virtual ~ProfileDownloaderMock() {
   }
 
   MOCK_CONST_METHOD0(GetProfileFullName, base::string16());
   MOCK_CONST_METHOD0(GetProfileGivenName, base::string16());
   MOCK_CONST_METHOD0(GetProfilePicture, SkBitmap());
   MOCK_CONST_METHOD0(GetProfilePictureStatus,
                      ProfileDownloader::PictureStatus());
   MOCK_CONST_METHOD0(GetProfilePictureURL, std::string());
+  MOCK_CONST_METHOD0(GetProfileHostedDomain, base::string16());
 };
 
 class GAIAInfoUpdateServiceMock : public GAIAInfoUpdateService {
  public:
   explicit GAIAInfoUpdateServiceMock(Profile* profile)
       : GAIAInfoUpdateService(profile) {
   }
 
   virtual ~GAIAInfoUpdateServiceMock() {
   }
@@ skipping 41 matching lines @@
     return base::UTF8ToUTF16(GivenName(id));
   }
   static base::string16 FullName16(const std::string& id) {
     return base::UTF8ToUTF16(FullName(id));
   }
 
   void ProfileDownloadSuccess(
       const base::string16& full_name,
       const base::string16& given_name,
       const gfx::Image& image,
-      const std::string& url) {
+      const std::string& url,
+      const base::string16& hosted_domain) {
     EXPECT_CALL(*downloader(), GetProfileFullName()).
         WillOnce(Return(full_name));
     EXPECT_CALL(*downloader(), GetProfileGivenName()).
         WillOnce(Return(given_name));
     const SkBitmap* bmp = image.ToSkBitmap();
     EXPECT_CALL(*downloader(), GetProfilePicture()).WillOnce(Return(*bmp));
     EXPECT_CALL(*downloader(), GetProfilePictureStatus()).
         WillOnce(Return(ProfileDownloader::PICTURE_SUCCESS));
     EXPECT_CALL(*downloader(), GetProfilePictureURL()).WillOnce(Return(url));
+    EXPECT_CALL(*downloader(), GetProfileHostedDomain()).
+        WillOnce(Return(hosted_domain));
 
     service()->OnProfileDownloadSuccess(downloader());
   }
 
   void RenameProfile(const base::string16& full_name,
                      const base::string16& given_name) {
     gfx::Image image = gfx::test::CreateImage(256,256);
     std::string url("foo.com");
-    ProfileDownloadSuccess(full_name, given_name, image, url);
+    ProfileDownloadSuccess(full_name, given_name, image, url, base::string16());
 
     // Make sure the right profile was updated correctly.
     size_t index = GetCache()->GetIndexOfProfileWithPath(profile()->GetPath());
     EXPECT_EQ(full_name, GetCache()->GetGAIANameOfProfileAtIndex(index));
     EXPECT_EQ(given_name, GetCache()->GetGAIAGivenNameOfProfileAtIndex(index));
   }
 
  private:
   virtual void SetUp() OVERRIDE;
   virtual void TearDown() OVERRIDE;
@@ skipping 14 matching lines @@
   service_->Shutdown();
   service_.reset();
   ProfileInfoCacheTest::TearDown();
 }
 
 } // namespace
 
 TEST_F(GAIAInfoUpdateServiceTest, DownloadSuccess) {
   // No URL should be cached yet.
   EXPECT_EQ(std::string(), service()->GetCachedPictureURL());
+  EXPECT_EQ(std::string(), profile()->GetPrefs()->
+      GetString(prefs::kGoogleServicesHostedDomain));
 
   base::string16 name = base::ASCIIToUTF16("Pat Smith");
   base::string16 given_name = base::ASCIIToUTF16("Pat");
   gfx::Image image = gfx::test::CreateImage(256, 256);
   std::string url("foo.com");
-  ProfileDownloadSuccess(name, given_name, image, url);
+  base::string16 hosted_domain(base::ASCIIToUTF16(""));
+  ProfileDownloadSuccess(name, given_name, image, url, hosted_domain);
 
   // On success the GAIA info should be updated.
   size_t index = GetCache()->GetIndexOfProfileWithPath(profile()->GetPath());
   EXPECT_EQ(name, GetCache()->GetGAIANameOfProfileAtIndex(index));
   EXPECT_EQ(given_name, GetCache()->GetGAIAGivenNameOfProfileAtIndex(index));
   EXPECT_TRUE(gfx::test::IsEqual(
       image, *GetCache()->GetGAIAPictureOfProfileAtIndex(index)));
   EXPECT_EQ(url, service()->GetCachedPictureURL());
+  EXPECT_EQ(Profile::kNoHostedDomainFound, profile()->GetPrefs()->
+      GetString(prefs::kGoogleServicesHostedDomain));
 }
 
 TEST_F(GAIAInfoUpdateServiceTest, DownloadFailure) {
   size_t index = GetCache()->GetIndexOfProfileWithPath(profile()->GetPath());
   base::string16 old_name = GetCache()->GetNameOfProfileAtIndex(index);
   gfx::Image old_image = GetCache()->GetAvatarIconOfProfileAtIndex(index);
 
   EXPECT_EQ(std::string(), service()->GetCachedPictureURL());
 
   service()->OnProfileDownloadFailure(downloader(),
                                       ProfileDownloaderDelegate::SERVICE_ERROR);
 
   // On failure nothing should be updated.
   EXPECT_EQ(old_name, GetCache()->GetNameOfProfileAtIndex(index));
   EXPECT_EQ(base::string16(), GetCache()->GetGAIANameOfProfileAtIndex(index));
   EXPECT_EQ(base::string16(),
             GetCache()->GetGAIAGivenNameOfProfileAtIndex(index));
   EXPECT_TRUE(gfx::test::IsEqual(
       old_image, GetCache()->GetAvatarIconOfProfileAtIndex(index)));
   EXPECT_EQ(NULL, GetCache()->GetGAIAPictureOfProfileAtIndex(index));
   EXPECT_EQ(std::string(), service()->GetCachedPictureURL());
+  EXPECT_EQ(std::string(),
+      profile()->GetPrefs()->GetString(prefs::kGoogleServicesHostedDomain));
+}
+
+TEST_F(GAIAInfoUpdateServiceTest, ProfileLockEnabledForWhitelist) {
+  // No URL should be cached yet.
+  EXPECT_EQ(std::string(), service()->GetCachedPictureURL());
+
+  base::string16 name = base::ASCIIToUTF16("Pat Smith");
+  base::string16 given_name = base::ASCIIToUTF16("Pat");
+  gfx::Image image = gfx::test::CreateImage(256, 256);
+  std::string url("foo.com");
+  base::string16 hosted_domain(base::ASCIIToUTF16("google.com"));
+  ProfileDownloadSuccess(name, given_name, image, url, hosted_domain);
+
+  EXPECT_EQ("google.com", profile()->GetPrefs()->
+      GetString(prefs::kGoogleServicesHostedDomain));
 }
 
 TEST_F(GAIAInfoUpdateServiceTest, HandlesProfileReordering) {
   size_t index = GetCache()->GetIndexOfProfileWithPath(profile()->GetPath());
   GetCache()->SetNameOfProfileAtIndex(index, FullName16("B"));
   GetCache()->SetProfileIsUsingDefaultNameAtIndex(index, true);
 
   CreateProfile(FullName("A"));
   CreateProfile(FullName("C"));
   CreateProfile(FullName("E"));
@@ skipping 71 matching lines @@
 
 TEST_F(GAIAInfoUpdateServiceTest, LogIn) {
   // Log in.
   EXPECT_CALL(*service(), Update());
   SigninManager* signin_manager =
       SigninManagerFactory::GetForProfile(profile());
   signin_manager->OnExternalSigninCompleted("pat@example.com");
 }
 
 #endif