Use content::MessageLoopRunner in a couple of Autofill tests.

components/autofill/browser/autofill_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 <algorithm>
 #include <vector>
 
 #include "base/command_line.h"
+#include "base/memory/ref_counted.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/memory/scoped_vector.h"
 #include "base/prefs/pref_service.h"
 #include "base/string16.h"
 #include "base/stringprintf.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/time.h"
 #include "base/tuple.h"
 #include "base/utf_string_conversions.h"
 #include "chrome/browser/autofill/personal_data_manager_factory.h"
@@ skipping 15 matching lines @@
 #include "components/autofill/browser/credit_card.h"
 #include "components/autofill/browser/personal_data_manager.h"
 #include "components/autofill/browser/test_autofill_external_delegate.h"
 #include "components/autofill/common/autofill_messages.h"
 #include "components/autofill/common/form_data.h"
 #include "components/autofill/common/form_field_data.h"
 #include "components/user_prefs/user_prefs.h"
 #include "content/public/browser/web_contents.h"
 #include "content/public/test/mock_render_process_host.h"
 #include "content/public/test/test_browser_thread.h"
+#include "content/public/test/test_utils.h"
 #include "googleurl/src/gurl.h"
 #include "grit/generated_resources.h"
 #include "ipc/ipc_test_sink.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebAutofillClient.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebFormElement.h"
 #include "ui/base/l10n/l10n_util.h"
 #include "ui/gfx/rect.h"
 
@@ skipping 423 matching lines @@
                    has_address_fields, true, true);
 }
 
 class TestAutofillManager : public AutofillManager {
  public:
   TestAutofillManager(content::WebContents* web_contents,
                       autofill::AutofillManagerDelegate* delegate,
                       TestPersonalDataManager* personal_data)
       : AutofillManager(web_contents, delegate, personal_data),
         personal_data_(personal_data),
-        autofill_enabled_(true),
-        did_finish_async_form_submit_(false),
-        message_loop_is_running_(false) {
-  }
+        autofill_enabled_(true) {}
   virtual ~TestAutofillManager() {}
 
   virtual bool IsAutofillEnabled() const OVERRIDE { return autofill_enabled_; }
 
   void set_autofill_enabled(bool autofill_enabled) {
     autofill_enabled_ = autofill_enabled;
   }
 
   void set_autocheckout_url_prefix(const std::string& autocheckout_url_prefix) {
     autocheckout_url_prefix_ = autocheckout_url_prefix;
@@ skipping 12 matching lines @@
   void set_expected_submitted_field_types(
       const std::vector<FieldTypeSet>& expected_types) {
     expected_submitted_field_types_ = expected_types;
   }
 
   virtual void UploadFormDataAsyncCallback(
       const FormStructure* submitted_form,
       const base::TimeTicks& load_time,
       const base::TimeTicks& interaction_time,
       const base::TimeTicks& submission_time) OVERRIDE {
-    if (message_loop_is_running_) {
-      MessageLoop::current()->Quit();
-      message_loop_is_running_ = false;
-    } else {
-      did_finish_async_form_submit_ = true;
-    }
+    message_loop_runner_->Quit();
 
     // If we have expected field types set, make sure they match.
     if (!expected_submitted_field_types_.empty()) {
       ASSERT_EQ(expected_submitted_field_types_.size(),
                 submitted_form->field_count());
       for (size_t i = 0; i < expected_submitted_field_types_.size(); ++i) {
         SCOPED_TRACE(
             base::StringPrintf(
                 "Field %d with value %s", static_cast<int>(i),
                 UTF16ToUTF8(submitted_form->field(i)->value).c_str()));
         const FieldTypeSet& possible_types =
             submitted_form->field(i)->possible_types();
         EXPECT_EQ(expected_submitted_field_types_[i].size(),
                   possible_types.size());
         for (FieldTypeSet::const_iterator it =
                  expected_submitted_field_types_[i].begin();
              it != expected_submitted_field_types_[i].end(); ++it) {
           EXPECT_TRUE(possible_types.count(*it))
               << "Expected type: " << AutofillType::FieldTypeToString(*it);
         }
       }
     }
 
     AutofillManager::UploadFormDataAsyncCallback(submitted_form,
                                                  load_time,
                                                  interaction_time,
                                                  submission_time);
   }
 
+  // Resets the MessageLoopRunner so that it can wait for an asynchronous form
+  // submission to complete.
+  void ResetMessageLoopRunner() {
+    message_loop_runner_ = new content::MessageLoopRunner();
+  }
+
   // Wait for the asynchronous OnFormSubmitted() call to complete.
   void WaitForAsyncFormSubmit() {
-    if (!did_finish_async_form_submit_) {
-      // TODO(isherman): It seems silly to need this variable.  Is there some
-      // way I can just query the message loop's state?
-      message_loop_is_running_ = true;
-      MessageLoop::current()->Run();
-    } else {
-      did_finish_async_form_submit_ = false;
-    }
+    message_loop_runner_->Run();
   }
 
   virtual void UploadFormData(const FormStructure& submitted_form) OVERRIDE {
     submitted_form_signature_ = submitted_form.FormSignature();
   }
 
   virtual void SendPasswordGenerationStateToRenderer(
       content::RenderViewHost* host, bool enabled) OVERRIDE {
     sent_states_.push_back(enabled);
   }
@@ skipping 48 matching lines @@
   }
 
  private:
   // Weak reference.
   TestPersonalDataManager* personal_data_;
 
   bool autofill_enabled_;
   std::vector<std::pair<WebFormElement::AutocompleteResult, FormData> >
       request_autocomplete_results_;
 
-  bool did_finish_async_form_submit_;
-  bool message_loop_is_running_;
+  scoped_refptr<content::MessageLoopRunner> message_loop_runner_;
 
   std::string autocheckout_url_prefix_;
   std::string submitted_form_signature_;
   std::vector<FieldTypeSet> expected_submitted_field_types_;
   std::vector<bool> sent_states_;
 
   DISALLOW_COPY_AND_ASSIGN(TestAutofillManager);
 };
 
 }  // namespace
@@ skipping 76 matching lines @@
 
   void FormsSeen(const std::vector<FormData>& forms) {
     autofill_manager_->OnFormsSeen(forms, base::TimeTicks(), false);
   }
 
   void PartialFormsSeen(const std::vector<FormData>& forms) {
     autofill_manager_->OnFormsSeen(forms, base::TimeTicks(), true);
   }
 
   void FormSubmitted(const FormData& form) {
+    autofill_manager_->ResetMessageLoopRunner();
     if (autofill_manager_->OnFormSubmitted(form, base::TimeTicks::Now()))
       autofill_manager_->WaitForAsyncFormSubmit();
   }
 
   void FillAutofillFormData(int query_id,
                             const FormData& form,
                             const FormFieldData& field,
                             int unique_id) {
     autofill_manager_->OnFillAutofillFormData(query_id, form, field, unique_id);
   }
@@ skipping 2589 matching lines @@
   CreateTestAddressFormData(&form);
   std::vector<FormData> forms(1, form);
   FormsSeen(forms);
   const FormFieldData& field = form.fields[0];
   GetAutofillSuggestions(form, field);  // should call the delegate's OnQuery()
 
   autofill_manager_->SetExternalDelegate(NULL);
 }
 
 }  // namespace autofill