Per the Chromium style guide/dos-and-donts doc, don't inline non-"cheap

chrome/browser/autofill/autofill_interactive_uitest.cc

 // Copyright (c) 2013 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 "base/memory/ref_counted.h"
 #include "base/memory/scoped_ptr.h"
 #include "chrome/browser/autofill/personal_data_manager_factory.h"
 #include "chrome/browser/chrome_notification_types.h"
 #include "chrome/browser/infobars/confirm_infobar_delegate.h"
 #include "chrome/browser/profiles/profile.h"
@@ skipping 56 matching lines @@
     " </select><br>"
     "<label for=\"phone\">Phone number:</label>"
     " <input type=\"text\" id=\"phone\"><br>"
     "</form>";
 
 class AutofillManagerTestDelegateImpl
     : public autofill::AutofillManagerTestDelegate {
  public:
   AutofillManagerTestDelegateImpl() {}
 
+  // autofill::AutofillManagerTestDelegate:
   virtual void DidPreviewFormData() OVERRIDE {
     loop_runner_->Quit();
   }
 
   virtual void DidFillFormData() OVERRIDE {
     loop_runner_->Quit();
   }
 
   virtual void DidShowSuggestions() OVERRIDE {
     loop_runner_->Quit();
@@ skipping 26 matching lines @@
         AddObserver(this);
     registrar_.Add(this, chrome::NOTIFICATION_TAB_CONTENTS_INFOBAR_ADDED,
                    content::NotificationService::AllSources());
   }
 
   virtual ~WindowedPersonalDataManagerObserver() {
     if (infobar_service_ && infobar_service_->infobar_count() > 0)
       infobar_service_->RemoveInfoBar(infobar_service_->infobar_at(0));
   }
 
-  void Wait() {
-    if (!alerted_) {
-      has_run_message_loop_ = true;
-      content::RunMessageLoop();
-    }
-    PersonalDataManagerFactory::GetForProfile(browser_->profile())->
-        RemoveObserver(this);
-  }
-
   // PersonalDataManagerObserver:
   virtual void OnPersonalDataChanged() OVERRIDE {
     if (has_run_message_loop_) {
       base::MessageLoopForUI::current()->Quit();
       has_run_message_loop_ = false;
     }
     alerted_ = true;
   }
 
   virtual void OnInsufficientFormData() OVERRIDE {
     OnPersonalDataChanged();
   }
 
   // content::NotificationObserver:
   virtual void Observe(int type,
                        const content::NotificationSource& source,
                        const content::NotificationDetails& details) OVERRIDE {
     // Accept in the infobar.
     infobar_service_ = InfoBarService::FromWebContents(
         browser_->tab_strip_model()->GetActiveWebContents());
     InfoBarDelegate* infobar = infobar_service_->infobar_at(0);
 
     ConfirmInfoBarDelegate* confirm_infobar =
         infobar->AsConfirmInfoBarDelegate();
     confirm_infobar->Accept();
   }
 
+  void Wait() {
+    if (!alerted_) {
+      has_run_message_loop_ = true;
+      content::RunMessageLoop();
+    }
+    PersonalDataManagerFactory::GetForProfile(browser_->profile())->
+        RemoveObserver(this);
+  }
+
  private:
   bool alerted_;
   bool has_run_message_loop_;
   Browser* browser_;
   content::NotificationRegistrar registrar_;
   InfoBarService* infobar_service_;
 };
 
 class TestAutofillExternalDelegate : public AutofillExternalDelegate {
  public:
   TestAutofillExternalDelegate(content::WebContents* web_contents,
                                AutofillManager* autofill_manager,
                                AutofillDriver* autofill_driver)
       : AutofillExternalDelegate(web_contents, autofill_manager,
                                  autofill_driver),
         keyboard_listener_(NULL) {
   }
   virtual ~TestAutofillExternalDelegate() {}
 
+  // AutofillExternalDelegate:
   virtual void OnPopupShown(content::KeyboardListener* listener) OVERRIDE {
     AutofillExternalDelegate::OnPopupShown(listener);
     keyboard_listener_ = listener;
   }
 
   virtual void OnPopupHidden(content::KeyboardListener* listener) OVERRIDE {
     keyboard_listener_ = NULL;
     AutofillExternalDelegate::OnPopupHidden(listener);
   }
 
   content::KeyboardListener* keyboard_listener() {
     return keyboard_listener_;
   }
 
  private:
   // The popup that is currently registered as a keyboard listener, or NULL if
   // there is none.
   content::KeyboardListener* keyboard_listener_;
 
   DISALLOW_COPY_AND_ASSIGN(TestAutofillExternalDelegate);
 };
 
 class AutofillInteractiveTest : public InProcessBrowserTest {
  protected:
   AutofillInteractiveTest() {}
 
+  // InProcessBrowserTest:
   virtual void SetUpOnMainThread() OVERRIDE {
     // Don't want Keychain coming up on Mac.
     test::DisableSystemServices(browser()->profile());
 
     // When testing the native UI, hook up a test external delegate, which
     // allows us to forward keyboard events to the popup directly.
     content::WebContents* web_contents =
         browser()->tab_strip_model()->GetActiveWebContents();
     AutofillDriverImpl* autofill_driver =
         AutofillDriverImpl::FromWebContents(web_contents);
     AutofillManager* autofill_manager = autofill_driver->autofill_manager();
     scoped_ptr<AutofillExternalDelegate> external_delegate(
         new TestAutofillExternalDelegate(web_contents, autofill_manager,
                                          autofill_driver));
     autofill_driver->SetAutofillExternalDelegate(external_delegate.Pass());
     autofill_manager->SetTestDelegate(&test_delegate_);
   }
 
   virtual void CleanUpOnMainThread() OVERRIDE {
     // Make sure to close any showing popups prior to tearing down the UI.
     content::WebContents* web_contents =
         browser()->tab_strip_model()->GetActiveWebContents();
     AutofillManager* autofill_manager =
         AutofillDriverImpl::FromWebContents(web_contents)->autofill_manager();
     autofill_manager->delegate()->HideAutofillPopup();
   }
 
-  PersonalDataManager* personal_data_manager() {
+  PersonalDataManager* GetPersonalDataManager() {
     return PersonalDataManagerFactory::GetForProfile(browser()->profile());
   }
 
+  content::RenderViewHost* GetRenderViewHost() {
+    return browser()->tab_strip_model()->GetActiveWebContents()->
+        GetRenderViewHost();
+  }
+
+  TestAutofillExternalDelegate* GetExternalDelegate() {
+    content::WebContents* web_contents =
+        browser()->tab_strip_model()->GetActiveWebContents();
+    AutofillDriverImpl* autofill_driver =
+        AutofillDriverImpl::FromWebContents(web_contents);
+    return static_cast<TestAutofillExternalDelegate*>(
+        autofill_driver->autofill_external_delegate());
+  }
+
   void CreateTestProfile() {
     AutofillProfile profile;
     test::SetProfileInfo(
         &profile, "Milton", "C.", "Waddams",
         "red.swingline@initech.com", "Initech", "4120 Freidrich Lane",
         "Basement", "Austin", "Texas", "78744", "US", "5125551234");
 
     WindowedPersonalDataManagerObserver observer(browser());
-    personal_data_manager()->AddProfile(profile);
+    GetPersonalDataManager()->AddProfile(profile);
 
     // AddProfile is asynchronous. Wait for it to finish before continuing the
     // tests.
     observer.Wait();
   }
 
   void ExpectFieldValue(const std::string& field_name,
                         const std::string& expected_value) {
     std::string value;
     ASSERT_TRUE(content::ExecuteScriptAndExtractString(
         browser()->tab_strip_model()->GetActiveWebContents(),
         "window.domAutomationController.send("
         "    document.getElementById('" + field_name + "').value);",
         &value));
     EXPECT_EQ(expected_value, value);
   }
 
-  RenderViewHost* render_view_host() {
-    return browser()->tab_strip_model()->GetActiveWebContents()->
-        GetRenderViewHost();
-  }
-
   void FocusFirstNameField() {
     LOG(WARNING) << "Clicking on the tab.";
     content::SimulateMouseClick(
         browser()->tab_strip_model()->GetActiveWebContents(),
         0,
         WebKit::WebMouseEvent::ButtonLeft);
 
     LOG(WARNING) << "Focusing the first name field.";
     bool result = false;
     ASSERT_TRUE(content::ExecuteScriptAndExtractBool(
-        render_view_host(),
+        GetRenderViewHost(),
         "if (document.readyState === 'complete')"
         "  document.getElementById('firstname').focus();"
         "else"
         "  domAutomationController.send(false);",
         &result));
     ASSERT_TRUE(result);
   }
 
   void ExpectFilledTestForm() {
     ExpectFieldValue("firstname", "Milton");
@@ skipping 11 matching lines @@
     test_delegate_.Reset();
     content::SimulateKeyPress(
         browser()->tab_strip_model()->GetActiveWebContents(),
         key, false, false, false, false);
     test_delegate_.Wait();
   }
 
   void SendKeyToPopupAndWait(ui::KeyboardCode key) {
     // TODO(isherman): Remove this condition once the WebKit popup UI code is
     // removed.
-    if (!external_delegate()) {
+    if (!GetExternalDelegate()) {
       // When testing the WebKit-based UI, route all keys to the page.
       SendKeyToPageAndWait(key);
       return;
     }
 
     // When testing the native UI, route popup-targeted key presses via the
     // external delegate.
     content::NativeWebKeyboardEvent event;
     event.windowsKeyCode = key;
     test_delegate_.Reset();
-    external_delegate()->keyboard_listener()->HandleKeyPressEvent(event);
+    GetExternalDelegate()->keyboard_listener()->HandleKeyPressEvent(event);
     test_delegate_.Wait();
   }
 
-  TestAutofillExternalDelegate* external_delegate() {
-    content::WebContents* web_contents =
-        browser()->tab_strip_model()->GetActiveWebContents();
-    AutofillDriverImpl* autofill_driver =
-        AutofillDriverImpl::FromWebContents(web_contents);
-    return static_cast<TestAutofillExternalDelegate*>(
-        autofill_driver->autofill_external_delegate());
-  }
-
   AutofillManagerTestDelegateImpl test_delegate_;
 };
 
 IN_PROC_BROWSER_TEST_F(AutofillInteractiveTest, DISABLED_AutofillSelectViaTab) {
   CreateTestProfile();
 
   // Load the test page.
   ASSERT_NO_FATAL_FAILURE(ui_test_utils::NavigateToURL(browser(),
       GURL(std::string(kDataURIPrefix) + kTestFormString)));
 
   // Focus a fillable field.
   FocusFirstNameField();
 
   // Press the down arrow to initiate Autofill and wait for the popup to be
   // shown.
   SendKeyToPageAndWait(ui::VKEY_DOWN);
 
   // Press the down arrow to select the suggestion and preview the autofilled
   // form.
   SendKeyToPopupAndWait(ui::VKEY_DOWN);
 
   // Press tab to accept the autofill suggestions.
   SendKeyToPopupAndWait(ui::VKEY_TAB);
 
   // The form should be filled.
   ExpectFilledTestForm();
 }
 
 }  // namespace autofill