Remove the Extensions URLRequestContext

chrome/browser/password_manager/password_form_manager_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 "testing/gtest/include/gtest/gtest.h"
 
 #include "base/memory/scoped_ptr.h"
-#include "base/message_loop/message_loop.h"
 #include "base/strings/string_util.h"
 #include "base/strings/utf_string_conversions.h"
 #include "chrome/browser/password_manager/password_form_manager.h"
 #include "chrome/browser/password_manager/password_manager.h"
 #include "chrome/browser/password_manager/password_manager_delegate.h"
 #include "chrome/browser/password_manager/password_store.h"
 #include "chrome/browser/password_manager/password_store_factory.h"
 #include "chrome/browser/password_manager/test_password_store.h"
 #include "chrome/browser/profiles/profile_manager.h"
 #include "chrome/test/base/testing_profile.h"
 #include "content/public/common/password_form.h"
+#include "content/public/test/test_browser_thread_bundle.h"
 #include "content/public/test/test_utils.h"
 #include "testing/gmock/include/gmock/gmock.h"
 
 using content::PasswordForm;
 
 using ::testing::Eq;
 
 class TestPasswordManagerDelegate : public PasswordManagerDelegate {
  public:
   explicit TestPasswordManagerDelegate(Profile* profile) : profile_(profile) {}
@@ skipping 37 matching lines @@
   size_t num_sent_messages() {
     return num_sent_messages_;
   }
 
  private:
   size_t num_sent_messages_;
 };
 
 class PasswordFormManagerTest : public testing::Test {
  public:
-  PasswordFormManagerTest() {
-  }
   virtual void SetUp() {
     observed_form_.origin = GURL("http://accounts.google.com/a/LoginAuth");
     observed_form_.action = GURL("http://accounts.google.com/a/Login");
     observed_form_.username_element = ASCIIToUTF16("Email");
     observed_form_.password_element = ASCIIToUTF16("Passwd");
     observed_form_.submit_element = ASCIIToUTF16("signIn");
     observed_form_.signon_realm = "http://accounts.google.com";
 
     saved_match_ = observed_form_;
     saved_match_.origin = GURL("http://accounts.google.com/a/ServiceLoginAuth");
     saved_match_.action = GURL("http://accounts.google.com/a/ServiceLogin");
     saved_match_.preferred = true;
     saved_match_.username_value = ASCIIToUTF16("test@gmail.com");
     saved_match_.password_value = ASCIIToUTF16("test1");
     saved_match_.other_possible_usernames.push_back(
         ASCIIToUTF16("test2@gmail.com"));
-    profile_ = new TestingProfile();
-  }
-
-  virtual void TearDown() {
-    delete profile_;
   }
 
   PasswordForm* GetPendingCredentials(PasswordFormManager* p) {
     return &p->pending_credentials_;
   }
 
   void SimulateMatchingPhase(PasswordFormManager* p, bool find_match) {
     // Roll up the state to mock out the matching phase.
     p->state_ = PasswordFormManager::POST_MATCHING_PHASE;
     if (!find_match)
@@ skipping 20 matching lines @@
   }
 
   void SanitizePossibleUsernames(PasswordFormManager* p, PasswordForm* form) {
     p->SanitizePossibleUsernames(form);
   }
 
   bool IgnoredResult(PasswordFormManager* p, PasswordForm* form) {
     return p->IgnoreResult(*form);
   }
 
-  Profile* profile() { return profile_; }
+  Profile* profile() { return &profile_; }
 
   PasswordForm* observed_form() { return &observed_form_; }
   PasswordForm* saved_match() { return &saved_match_; }
   PasswordForm* CreateSavedMatch(bool blacklisted) {
     // Owned by the caller of this method.
     PasswordForm* match = new PasswordForm(saved_match_);
     match->blacklisted_by_user = blacklisted;
     return match;
   }
 
  private:
+  content::TestBrowserThreadBundle thread_bundle_;
+  TestingProfile profile_;
   PasswordForm observed_form_;
   PasswordForm saved_match_;
-  Profile* profile_;
 };
 
 TEST_F(PasswordFormManagerTest, TestNewLogin) {
   PasswordFormManager* manager = new PasswordFormManager(
       profile(), NULL, NULL, *observed_form(), false);
   SimulateMatchingPhase(manager, false);
   // User submits credentials for the observed form.
   PasswordForm credentials = *observed_form();
   credentials.username_value = saved_match()->username_value;
   credentials.password_value = saved_match()->password_value;
@@ skipping 161 matching lines @@
       login,
       PasswordFormManager::IGNORE_OTHER_POSSIBLE_USERNAMES);
   EXPECT_TRUE(manager->IsNewLogin());
   // Check that the provisionally saved action URL is the same as the submitted
   // action URL, not the one observed on page load.
   EXPECT_EQ(new_action,
             GetPendingCredentials(manager.get())->action);
 }
 
 TEST_F(PasswordFormManagerTest, TestAlternateUsername) {
-  // Need a MessageLoop for callbacks.
-  base::MessageLoop message_loop;
   PasswordStoreFactory::GetInstance()->SetTestingFactory(
       profile(), &TestPasswordStore::Create);
   scoped_refptr<TestPasswordStore> password_store =
       static_cast<TestPasswordStore*>(
           PasswordStoreFactory::GetForProfile(profile(),
                                               Profile::IMPLICIT_ACCESS).get());
   TestPasswordManagerDelegate delegate(profile());
   TestPasswordManager password_manager(&delegate);
   scoped_ptr<TestPasswordFormManager> manager(new TestPasswordFormManager(
       profile(), &password_manager, *observed_form(), false));
@@ skipping 189 matching lines @@
 
   SanitizePossibleUsernames(manager.get(), &credentials);
 
   // SSN, duplicate in |other_possible_usernames| and duplicate of
   // |username_value| all removed.
   expected.clear();
   expected.push_back(ASCIIToUTF16("duplicate"));
   expected.push_back(ASCIIToUTF16("random"));
   EXPECT_THAT(credentials.other_possible_usernames, Eq(expected));
 }