1 // Copyright 2014 The Chromium Authors. All rights reserved. 2 // Use of this source code is governed by a BSD-style license that can be 3 // found in the LICENSE file. 4 5 #include "chrome/browser/ui/sync/one_click_signin_sync_observer.h" 6 7 #include "base/bind.h" 8 #include "base/callback.h" 9 #include "chrome/browser/signin/profile_oauth2_token_service_factory.h" 10 #include "chrome/browser/signin/signin_manager_factory.h" 11 #include "chrome/browser/signin/signin_promo.h" 12 #include "chrome/browser/sync/profile_sync_service_factory.h" 13 #include "chrome/browser/sync/startup_controller.h" 14 #include "chrome/browser/sync/test_profile_sync_service.h" 15 #include "chrome/test/base/chrome_render_view_host_test_harness.h" 16 #include "chrome/test/base/testing_profile.h" 17 #include "components/signin/core/browser/signin_manager.h" 18 #include "content/public/browser/render_view_host.h" 19 #include "content/public/browser/web_contents.h" 20 #include "content/public/test/test_utils.h" 21 #include "testing/gmock/include/gmock/gmock.h" 22 #include "testing/gtest/include/gtest/gtest.h" 23 24 using testing::_; 25 26 namespace { 27 28 const char kContinueUrl[] = "https://www.example.com/"; 29 30 class MockWebContentsObserver : public content::WebContentsObserver { 31 public: 32 explicit MockWebContentsObserver(content::WebContents* web_contents) 33 : content::WebContentsObserver(web_contents) {} 34 virtual ~MockWebContentsObserver() {} 35 36 // A hook to verify that the OneClickSigninSyncObserver initiated a redirect 37 // to the continue URL. Navigations in unit_tests never complete, but a 38 // navigation start is a sufficient signal for the purposes of this test. 39 // Listening for this call also has the advantage of being synchronous. 40 MOCK_METHOD1(AboutToNavigateRenderView, void(content::RenderViewHost*)); 41 }; 42 43 class OneClickTestProfileSyncService : public TestProfileSyncService { 44 public: 45 virtual ~OneClickTestProfileSyncService() {} 46 47 // Helper routine to be used in conjunction with 48 // BrowserContextKeyedServiceFactory::SetTestingFactory(). 49 static KeyedService* Build(content::BrowserContext* profile) { 50 return new OneClickTestProfileSyncService(static_cast<Profile*>(profile)); 51 } 52 53 virtual bool FirstSetupInProgress() const OVERRIDE { 54 return first_setup_in_progress_; 55 } 56 57 virtual bool sync_initialized() const OVERRIDE { return sync_initialized_; } 58 59 void set_first_setup_in_progress(bool in_progress) { 60 first_setup_in_progress_ = in_progress; 61 } 62 63 void set_sync_initialized(bool initialized) { 64 sync_initialized_ = initialized; 65 } 66 67 private: 68 explicit OneClickTestProfileSyncService(Profile* profile) 69 : TestProfileSyncService( 70 NULL, 71 profile, 72 SigninManagerFactory::GetForProfile(profile), 73 ProfileOAuth2TokenServiceFactory::GetForProfile(profile), 74 browser_sync::MANUAL_START), 75 first_setup_in_progress_(false), 76 sync_initialized_(false) {} 77 78 bool first_setup_in_progress_; 79 bool sync_initialized_; 80 }; 81 82 class TestOneClickSigninSyncObserver : public OneClickSigninSyncObserver { 83 public: 84 typedef base::Callback<void(TestOneClickSigninSyncObserver*)> 85 DestructionCallback; 86 87 TestOneClickSigninSyncObserver(content::WebContents* web_contents, 88 const GURL& continue_url, 89 const DestructionCallback& callback) 90 : OneClickSigninSyncObserver(web_contents, continue_url), 91 destruction_callback_(callback) {} 92 virtual ~TestOneClickSigninSyncObserver() { destruction_callback_.Run(this); } 93 94 private: 95 DestructionCallback destruction_callback_; 96 97 DISALLOW_COPY_AND_ASSIGN(TestOneClickSigninSyncObserver); 98 }; 99 100 // A trivial factory to build a null service. 101 KeyedService* BuildNullService(content::BrowserContext* context) { 102 return NULL; 103 } 104 105 } // namespace 106 107 class OneClickSigninSyncObserverTest : public ChromeRenderViewHostTestHarness { 108 public: 109 OneClickSigninSyncObserverTest() 110 : sync_service_(NULL), 111 sync_observer_(NULL), 112 sync_observer_destroyed_(true) {} 113 114 virtual void SetUp() OVERRIDE { 115 ChromeRenderViewHostTestHarness::SetUp(); 116 web_contents_observer_.reset(new MockWebContentsObserver(web_contents())); 117 sync_service_ = 118 static_cast<OneClickTestProfileSyncService*>( 119 ProfileSyncServiceFactory::GetInstance()->SetTestingFactoryAndUse( 120 profile(), OneClickTestProfileSyncService::Build)); 121 } 122 123 virtual void TearDown() OVERRIDE { 124 // Verify that the |sync_observer_| unregistered as an observer from the 125 // sync service and freed its memory. 126 EXPECT_TRUE(sync_observer_destroyed_); 127 if (sync_service_) 128 EXPECT_FALSE(sync_service_->HasObserver(sync_observer_)); 129 ChromeRenderViewHostTestHarness::TearDown(); 130 } 131 132 protected: 133 void CreateSyncObserver(const std::string& url) { 134 sync_observer_ = new TestOneClickSigninSyncObserver( 135 web_contents(), GURL(url), 136 base::Bind(&OneClickSigninSyncObserverTest::OnSyncObserverDestroyed, 137 base::Unretained(this))); 138 if (sync_service_) 139 EXPECT_TRUE(sync_service_->HasObserver(sync_observer_)); 140 EXPECT_TRUE(sync_observer_destroyed_); 141 sync_observer_destroyed_ = false; 142 } 143 144 OneClickTestProfileSyncService* sync_service_; 145 scoped_ptr<MockWebContentsObserver> web_contents_observer_; 146 147 private: 148 void OnSyncObserverDestroyed(TestOneClickSigninSyncObserver* observer) { 149 EXPECT_EQ(sync_observer_, observer); 150 EXPECT_FALSE(sync_observer_destroyed_); 151 sync_observer_destroyed_ = true; 152 } 153 154 TestOneClickSigninSyncObserver* sync_observer_; 155 bool sync_observer_destroyed_; 156 }; 157 158 // Verify that if no Sync service is present, e.g. because Sync is disabled, the 159 // observer immediately loads the continue URL. 160 TEST_F(OneClickSigninSyncObserverTest, NoSyncService_RedirectsImmediately) { 161 // Simulate disabling Sync. 162 sync_service_ = 163 static_cast<OneClickTestProfileSyncService*>( 164 ProfileSyncServiceFactory::GetInstance()->SetTestingFactoryAndUse( 165 profile(), BuildNullService)); 166 167 // The observer should immediately redirect to the continue URL. 168 EXPECT_CALL(*web_contents_observer_, AboutToNavigateRenderView(_)); 169 CreateSyncObserver(kContinueUrl); 170 EXPECT_EQ(GURL(kContinueUrl), web_contents()->GetVisibleURL()); 171 172 // The |sync_observer_| will be destroyed asynchronously, so manually pump 173 // the message loop to wait for the destruction. 174 content::RunAllPendingInMessageLoop(); 175 } 176 177 // Verify that when the WebContents is destroyed without any Sync notifications 178 // firing, the observer cleans up its memory without loading the continue URL. 179 TEST_F(OneClickSigninSyncObserverTest, WebContentsDestroyed) { 180 EXPECT_CALL(*web_contents_observer_, AboutToNavigateRenderView(_)).Times(0); 181 CreateSyncObserver(kContinueUrl); 182 SetContents(NULL); 183 } 184 185 // Verify that when Sync is configured successfully, the observer loads the 186 // continue URL and cleans up after itself. 187 TEST_F(OneClickSigninSyncObserverTest, 188 OnSyncStateChanged_SyncConfiguredSuccessfully) { 189 CreateSyncObserver(kContinueUrl); 190 sync_service_->set_first_setup_in_progress(false); 191 sync_service_->set_sync_initialized(true); 192 193 EXPECT_CALL(*web_contents_observer_, AboutToNavigateRenderView(_)); 194 sync_service_->NotifyObservers(); 195 EXPECT_EQ(GURL(kContinueUrl), web_contents()->GetVisibleURL()); 196 } 197 198 // Verify that when Sync configuration fails, the observer does not load the 199 // continue URL, but still cleans up after itself. 200 TEST_F(OneClickSigninSyncObserverTest, 201 OnSyncStateChanged_SyncConfigurationFailed) { 202 CreateSyncObserver(kContinueUrl); 203 sync_service_->set_first_setup_in_progress(false); 204 sync_service_->set_sync_initialized(false); 205 206 EXPECT_CALL(*web_contents_observer_, AboutToNavigateRenderView(_)).Times(0); 207 sync_service_->NotifyObservers(); 208 EXPECT_NE(GURL(kContinueUrl), web_contents()->GetVisibleURL()); 209 } 210 211 // Verify that when Sync sends a notification while setup is not yet complete, 212 // the observer does not load the continue URL, and continues to wait. 213 TEST_F(OneClickSigninSyncObserverTest, 214 OnSyncStateChanged_SyncConfigurationInProgress) { 215 CreateSyncObserver(kContinueUrl); 216 sync_service_->set_first_setup_in_progress(true); 217 sync_service_->set_sync_initialized(false); 218 219 EXPECT_CALL(*web_contents_observer_, AboutToNavigateRenderView(_)).Times(0); 220 sync_service_->NotifyObservers(); 221 EXPECT_NE(GURL(kContinueUrl), web_contents()->GetVisibleURL()); 222 223 // Trigger an event to force state to be cleaned up. 224 SetContents(NULL); 225 } 226 227 // Verify that if the continue_url is to the settings page, no navigation is 228 // triggered, since it would be redundant. 229 TEST_F(OneClickSigninSyncObserverTest, 230 OnSyncStateChanged_SyncConfiguredSuccessfully_SourceIsSettings) { 231 GURL continue_url = signin::GetPromoURL(signin::SOURCE_SETTINGS, false); 232 CreateSyncObserver(continue_url.spec()); 233 sync_service_->set_first_setup_in_progress(false); 234 sync_service_->set_sync_initialized(true); 235 236 EXPECT_CALL(*web_contents_observer_, AboutToNavigateRenderView(_)).Times(0); 237 sync_service_->NotifyObservers(); 238 EXPECT_NE(GURL(kContinueUrl), web_contents()->GetVisibleURL()); 239 } 240