chrome/browser/sync/test/integration/passwords_helper.cc

   1 // Copyright (c) 2012 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/sync/test/integration/passwords_helper.h"
   6
   7 #include "base/compiler_specific.h"
   8 #include "base/strings/stringprintf.h"
   9 #include "base/strings/utf_string_conversions.h"
  10 #include "base/synchronization/waitable_event.h"
  11 #include "base/time/time.h"
  12 #include "chrome/browser/password_manager/password_store_factory.h"
  13 #include "chrome/browser/sync/profile_sync_service.h"
  14 #include "chrome/browser/sync/profile_sync_service_factory.h"
  15 #include "chrome/browser/sync/test/integration/multi_client_status_change_checker.h"
  16 #include "chrome/browser/sync/test/integration/profile_sync_service_harness.h"
  17 #include "chrome/browser/sync/test/integration/single_client_status_change_checker.h"
  18 #include "chrome/browser/sync/test/integration/sync_datatype_helper.h"
  19 #include "chrome/test/base/ui_test_utils.h"
  20 #include "components/password_manager/core/browser/password_form_data.h"
  21 #include "components/password_manager/core/browser/password_store.h"
  22 #include "components/password_manager/core/browser/password_store_consumer.h"
  23
  24 using autofill::PasswordForm;
  25 using password_manager::PasswordStore;
  26 using sync_datatype_helper::test;
  27
  28 const std::string kFakeSignonRealm = "http://fake-signon-realm.google.com/";
  29 const char* kIndexedFakeOrigin = "http://fake-signon-realm.google.com/%d";
  30
  31 namespace {
  32
  33 // We use a WaitableEvent to wait when logins are added, removed, or updated
  34 // instead of running the UI message loop because of a restriction that
  35 // prevents a DB thread from initiating a quit of the UI message loop.
  36 void PasswordStoreCallback(base::WaitableEvent* wait_event) {
  37   // Wake up passwords_helper::AddLogin.
  38   wait_event->Signal();
  39 }
  40
  41 class PasswordStoreConsumerHelper
  42     : public password_manager::PasswordStoreConsumer {
  43  public:
  44   explicit PasswordStoreConsumerHelper(std::vector<PasswordForm>* result)
  45       : password_manager::PasswordStoreConsumer(), result_(result) {}
  46
  47   virtual void OnGetPasswordStoreResults(
  48       const std::vector<PasswordForm*>& result) OVERRIDE {
  49     result_->clear();
  50     for (std::vector<PasswordForm*>::const_iterator it = result.begin();
  51          it != result.end();
  52          ++it) {
  53       result_->push_back(**it);
  54       delete *it;
  55     }
  56
  57     // Quit the message loop to wake up passwords_helper::GetLogins.
  58     base::MessageLoopForUI::current()->Quit();
  59   }
  60
  61  private:
  62   std::vector<PasswordForm>* result_;
  63
  64   DISALLOW_COPY_AND_ASSIGN(PasswordStoreConsumerHelper);
  65 };
  66
  67 // PasswordForm::date_synced is a local field. Therefore it may be different
  68 // across clients.
  69 void ClearSyncDateField(std::vector<PasswordForm>* forms) {
  70   for (std::vector<PasswordForm>::iterator it = forms->begin();
  71        it != forms->end();
  72        ++it) {
  73     it->date_synced = base::Time();
  74   }
  75 }
  76
  77 }  // namespace
  78
  79 namespace passwords_helper {
  80
  81 void AddLogin(PasswordStore* store, const PasswordForm& form) {
  82   ASSERT_TRUE(store);
  83   base::WaitableEvent wait_event(true, false);
  84   store->AddLogin(form);
  85   store->ScheduleTask(base::Bind(&PasswordStoreCallback, &wait_event));
  86   wait_event.Wait();
  87 }
  88
  89 void UpdateLogin(PasswordStore* store, const PasswordForm& form) {
  90   ASSERT_TRUE(store);
  91   base::WaitableEvent wait_event(true, false);
  92   store->UpdateLogin(form);
  93   store->ScheduleTask(base::Bind(&PasswordStoreCallback, &wait_event));
  94   wait_event.Wait();
  95 }
  96
  97 void GetLogins(PasswordStore* store, std::vector<PasswordForm>& matches) {
  98   ASSERT_TRUE(store);
  99   PasswordForm matcher_form;
 100   matcher_form.signon_realm = kFakeSignonRealm;
 101   PasswordStoreConsumerHelper consumer(&matches);
 102   store->GetLogins(matcher_form, PasswordStore::DISALLOW_PROMPT, &consumer);
 103   content::RunMessageLoop();
 104 }
 105
 106 void RemoveLogin(PasswordStore* store, const PasswordForm& form) {
 107   ASSERT_TRUE(store);
 108   base::WaitableEvent wait_event(true, false);
 109   store->RemoveLogin(form);
 110   store->ScheduleTask(base::Bind(&PasswordStoreCallback, &wait_event));
 111   wait_event.Wait();
 112 }
 113
 114 void RemoveLogins(PasswordStore* store) {
 115   std::vector<PasswordForm> forms;
 116   GetLogins(store, forms);
 117   for (std::vector<PasswordForm>::iterator it = forms.begin();
 118        it != forms.end(); ++it) {
 119     RemoveLogin(store, *it);
 120   }
 121 }
 122
 123 void SetEncryptionPassphrase(int index,
 124                              const std::string& passphrase,
 125                              ProfileSyncService::PassphraseType type) {
 126   ProfileSyncServiceFactory::GetForProfile(
 127       test()->GetProfile(index))->SetEncryptionPassphrase(passphrase, type);
 128 }
 129
 130 bool SetDecryptionPassphrase(int index, const std::string& passphrase) {
 131   return ProfileSyncServiceFactory::GetForProfile(
 132       test()->GetProfile(index))->SetDecryptionPassphrase(passphrase);
 133 }
 134
 135 PasswordStore* GetPasswordStore(int index) {
 136   return PasswordStoreFactory::GetForProfile(test()->GetProfile(index),
 137                                              Profile::IMPLICIT_ACCESS).get();
 138 }
 139
 140 PasswordStore* GetVerifierPasswordStore() {
 141   return PasswordStoreFactory::GetForProfile(test()->verifier(),
 142                                              Profile::IMPLICIT_ACCESS).get();
 143 }
 144
 145 bool ProfileContainsSamePasswordFormsAsVerifier(int index) {
 146   std::vector<PasswordForm> verifier_forms;
 147   std::vector<PasswordForm> forms;
 148   GetLogins(GetVerifierPasswordStore(), verifier_forms);
 149   GetLogins(GetPasswordStore(index), forms);
 150   ClearSyncDateField(&forms);
 151   bool result =
 152       password_manager::ContainsSamePasswordForms(verifier_forms, forms);
 153   if (!result) {
 154     LOG(ERROR) << "Password forms in Verifier Profile:";
 155     for (std::vector<PasswordForm>::iterator it = verifier_forms.begin();
 156          it != verifier_forms.end(); ++it) {
 157       LOG(ERROR) << *it << std::endl;
 158     }
 159     LOG(ERROR) << "Password forms in Profile" << index << ":";
 160     for (std::vector<PasswordForm>::iterator it = forms.begin();
 161          it != forms.end(); ++it) {
 162       LOG(ERROR) << *it << std::endl;
 163     }
 164   }
 165   return result;
 166 }
 167
 168 bool ProfilesContainSamePasswordForms(int index_a, int index_b) {
 169   std::vector<PasswordForm> forms_a;
 170   std::vector<PasswordForm> forms_b;
 171   GetLogins(GetPasswordStore(index_a), forms_a);
 172   GetLogins(GetPasswordStore(index_b), forms_b);
 173   ClearSyncDateField(&forms_a);
 174   ClearSyncDateField(&forms_b);
 175   bool result = password_manager::ContainsSamePasswordForms(forms_a, forms_b);
 176   if (!result) {
 177     LOG(ERROR) << "Password forms in Profile" << index_a << ":";
 178     for (std::vector<PasswordForm>::iterator it = forms_a.begin();
 179          it != forms_a.end(); ++it) {
 180       LOG(ERROR) << *it << std::endl;
 181     }
 182     LOG(ERROR) << "Password forms in Profile" << index_b << ":";
 183     for (std::vector<PasswordForm>::iterator it = forms_b.begin();
 184          it != forms_b.end(); ++it) {
 185       LOG(ERROR) << *it << std::endl;
 186     }
 187   }
 188   return result;
 189 }
 190
 191 bool AllProfilesContainSamePasswordFormsAsVerifier() {
 192   for (int i = 0; i < test()->num_clients(); ++i) {
 193     if (!ProfileContainsSamePasswordFormsAsVerifier(i)) {
 194       DVLOG(1) << "Profile " << i << " does not contain the same password"
 195                                      " forms as the verifier.";
 196       return false;
 197     }
 198   }
 199   return true;
 200 }
 201
 202 bool AllProfilesContainSamePasswordForms() {
 203   for (int i = 1; i < test()->num_clients(); ++i) {
 204     if (!ProfilesContainSamePasswordForms(0, i)) {
 205       DVLOG(1) << "Profile " << i << " does not contain the same password"
 206                                      " forms as Profile 0.";
 207       return false;
 208     }
 209   }
 210   return true;
 211 }
 212
 213 namespace {
 214
 215 // Helper class used in the implementation of
 216 // AwaitAllProfilesContainSamePasswordForms.
 217 class SamePasswordFormsChecker : public MultiClientStatusChangeChecker {
 218  public:
 219   SamePasswordFormsChecker();
 220   virtual ~SamePasswordFormsChecker();
 221
 222   virtual bool IsExitConditionSatisfied() OVERRIDE;
 223   virtual std::string GetDebugMessage() const OVERRIDE;
 224
 225  private:
 226   bool in_progress_;
 227   bool needs_recheck_;
 228 };
 229
 230 SamePasswordFormsChecker::SamePasswordFormsChecker()
 231     : MultiClientStatusChangeChecker(
 232         sync_datatype_helper::test()->GetSyncServices()),
 233       in_progress_(false),
 234       needs_recheck_(false) {}
 235
 236 SamePasswordFormsChecker::~SamePasswordFormsChecker() {}
 237
 238 // This method needs protection against re-entrancy.
 239 //
 240 // This function indirectly calls GetLogins(), which starts a RunLoop on the UI
 241 // thread.  This can be a problem, since the next task to execute could very
 242 // well contain a ProfileSyncService::OnStateChanged() event, which would
 243 // trigger another call to this here function, and start another layer of
 244 // nested RunLoops.  That makes the StatusChangeChecker's Quit() method
 245 // ineffective.
 246 //
 247 // The work-around is to not allow re-entrancy.  But we can't just drop
 248 // IsExitConditionSatisifed() calls if one is already in progress.  Instead, we
 249 // set a flag to ask the current execution of IsExitConditionSatisfied() to be
 250 // re-run.  This ensures that the return value is always based on the most
 251 // up-to-date state.
 252 bool SamePasswordFormsChecker::IsExitConditionSatisfied() {
 253   if (in_progress_) {
 254     LOG(WARNING) << "Setting flag and returning early to prevent nesting.";
 255     needs_recheck_ = true;
 256     return false;
 257   }
 258
 259   // Keep retrying until we get a good reading.
 260   bool result = false;
 261   in_progress_ = true;
 262   do {
 263     needs_recheck_ = false;
 264     result = AllProfilesContainSamePasswordForms();
 265   } while (needs_recheck_);
 266   in_progress_ = false;
 267   return result;
 268 }
 269
 270 std::string SamePasswordFormsChecker::GetDebugMessage() const {
 271   return "Waiting for matching passwords";
 272 }
 273
 274 }  //  namespace
 275
 276 bool AwaitAllProfilesContainSamePasswordForms() {
 277   SamePasswordFormsChecker checker;
 278   checker.Wait();
 279   return !checker.TimedOut();
 280 }
 281
 282 namespace {
 283
 284 // Helper class used in the implementation of
 285 // AwaitProfileContainSamePasswordFormsAsVerifier.
 286 class SamePasswordFormsAsVerifierChecker
 287     : public SingleClientStatusChangeChecker {
 288  public:
 289   explicit SamePasswordFormsAsVerifierChecker(int index);
 290   virtual ~SamePasswordFormsAsVerifierChecker();
 291
 292   virtual bool IsExitConditionSatisfied() OVERRIDE;
 293   virtual std::string GetDebugMessage() const OVERRIDE;
 294
 295  private:
 296   int index_;
 297
 298   bool in_progress_;
 299   bool needs_recheck_;
 300 };
 301
 302 SamePasswordFormsAsVerifierChecker::SamePasswordFormsAsVerifierChecker(int i)
 303     : SingleClientStatusChangeChecker(
 304           sync_datatype_helper::test()->GetSyncService(i)),
 305       index_(i),
 306       in_progress_(false),
 307       needs_recheck_(false) {
 308 }
 309
 310 SamePasswordFormsAsVerifierChecker::~SamePasswordFormsAsVerifierChecker() {
 311 }
 312
 313 // This method uses the same re-entrancy prevention trick as
 314 // the SamePasswordFormsChecker.
 315 bool SamePasswordFormsAsVerifierChecker::IsExitConditionSatisfied() {
 316   if (in_progress_) {
 317     LOG(WARNING) << "Setting flag and returning early to prevent nesting.";
 318     needs_recheck_ = true;
 319     return false;
 320   }
 321
 322   // Keep retrying until we get a good reading.
 323   bool result = false;
 324   in_progress_ = true;
 325   do {
 326     needs_recheck_ = false;
 327     result = ProfileContainsSamePasswordFormsAsVerifier(index_);
 328   } while (needs_recheck_);
 329   in_progress_ = false;
 330   return result;
 331 }
 332
 333 std::string SamePasswordFormsAsVerifierChecker::GetDebugMessage() const {
 334   return "Waiting for passwords to match verifier";
 335 }
 336
 337 }  //  namespace
 338
 339 bool AwaitProfileContainsSamePasswordFormsAsVerifier(int index) {
 340   SamePasswordFormsAsVerifierChecker checker(index);
 341   checker.Wait();
 342   return !checker.TimedOut();
 343 }
 344
 345 int GetPasswordCount(int index) {
 346   std::vector<PasswordForm> forms;
 347   GetLogins(GetPasswordStore(index), forms);
 348   return forms.size();
 349 }
 350
 351 int GetVerifierPasswordCount() {
 352   std::vector<PasswordForm> verifier_forms;
 353   GetLogins(GetVerifierPasswordStore(), verifier_forms);
 354   return verifier_forms.size();
 355 }
 356
 357 PasswordForm CreateTestPasswordForm(int index) {
 358   PasswordForm form;
 359   form.signon_realm = kFakeSignonRealm;
 360   form.origin = GURL(base::StringPrintf(kIndexedFakeOrigin, index));
 361   form.username_value =
 362       base::ASCIIToUTF16(base::StringPrintf("username%d", index));
 363   form.password_value =
 364       base::ASCIIToUTF16(base::StringPrintf("password%d", index));
 365   form.date_created = base::Time::Now();
 366   return form;
 367 }
 368
 369 }  // namespace passwords_helper