Style: move non-simple getters from hacker_style to CamelCase.

chrome/browser/prerender/prerender_browsertest.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 <deque>
 
 #include "base/command_line.h"
 #include "base/path_service.h"
 #include "base/string_util.h"
 #include "base/stringprintf.h"
@@ skipping 677 matching lines @@
   }
 
   // Should be const but test_server()->GetURL(...) is not const.
   void NavigateToURL(const std::string& dest_html_file) {
     GURL dest_url = test_server()->GetURL(dest_html_file);
     NavigateToURLImpl(dest_url, CURRENT_TAB);
   }
 
   bool UrlIsInPrerenderManager(const std::string& html_file) {
     GURL dest_url = test_server()->GetURL(html_file);
-    return (prerender_manager()->FindEntry(dest_url) != NULL);
+    return (GetPrerenderManager()->FindEntry(dest_url) != NULL);
   }
 
   bool UrlIsInPrerenderManager(const GURL& url) {
-    return (prerender_manager()->FindEntry(url) != NULL);
+    return (GetPrerenderManager()->FindEntry(url) != NULL);
   }
 
   bool UrlIsPendingInPrerenderManager(const std::string& html_file) {
     GURL dest_url = test_server()->GetURL(html_file);
-    return prerender_manager()->IsPendingEntry(dest_url);
+    return GetPrerenderManager()->IsPendingEntry(dest_url);
   }
 
   void set_use_https_src(bool use_https_src_server) {
     use_https_src_server_ = use_https_src_server;
   }
 
   void DisableJavascriptCalls() {
     call_javascript_ = false;
   }
 
-  TaskManagerModel* model() const {
+  TaskManagerModel* GetModel() const {
     return TaskManager::GetInstance()->model();
   }
 
-  PrerenderManager* prerender_manager() const {
+  PrerenderManager* GetPrerenderManager() const {
     Profile* profile =
         current_browser()->GetSelectedTabContentsWrapper()->profile();
     PrerenderManager* prerender_manager =
         PrerenderManagerFactory::GetForProfile(profile);
     return prerender_manager;
   }
 
   // Returns length of |prerender_manager_|'s history, or -1 on failure.
   int GetHistoryLength() const {
     scoped_ptr<DictionaryValue> prerender_dict(
-        static_cast<DictionaryValue*>(prerender_manager()->GetAsValue()));
+        static_cast<DictionaryValue*>(GetPrerenderManager()->GetAsValue()));
     if (!prerender_dict.get())
       return -1;
     ListValue* history_list;
     if (!prerender_dict->GetList("history", &history_list))
       return -1;
     return static_cast<int>(history_list->GetSize());
   }
 
 #if defined(ENABLE_SAFE_BROWSING)
   FakeSafeBrowsingService* GetSafeBrowsingService() {
     return safe_browsing_factory_->most_recent_service();
   }
 #endif
 
   TestPrerenderContents* GetPrerenderContents() const {
     return static_cast<TestPrerenderContents*>(
-        prerender_manager()->FindEntry(dest_url_));
+        GetPrerenderManager()->FindEntry(dest_url_));
   }
 
   void set_loader_path(const std::string& path) {
     loader_path_ = path;
   }
 
   GURL GetCrossDomainTestUrl(const std::string& path) {
     static const std::string secondary_domain = "www.foo.com";
     host_resolver()->AddRule(secondary_domain, "127.0.0.1");
     std::string url_str(base::StringPrintf(
@@ skipping 13 matching lines @@
       return explicitly_set_browser_;
     else
       return browser();
   }
 
   void IncreasePrerenderMemory() {
     // Increase the memory allowed in a prerendered page above normal settings.
     // Debug build bots occasionally run against the default limit, and tests
     // were failing because the prerender was canceled due to memory exhaustion.
     // http://crbug.com/93076
-    prerender_manager()->mutable_config().max_bytes = 1000 * 1024 * 1024;
+    GetPrerenderManager()->mutable_config().max_bytes = 1000 * 1024 * 1024;
   }
 
  private:
   void PrerenderTestURLImpl(
       const GURL& prerender_url,
       const GURL& destination_url,
       const std::deque<FinalStatus>& expected_final_status_queue,
       int expected_number_of_loads,
       bool prerender_should_wait_for_ready_title) {
     dest_url_ = destination_url;
@@ skipping 14 matching lines @@
     if (use_https_src_server_) {
       https_src_server.reset(
           new net::TestServer(net::TestServer::TYPE_HTTPS,
                               net::TestServer::kLocalhost,
                               FilePath(FILE_PATH_LITERAL("chrome/test/data"))));
       ASSERT_TRUE(https_src_server->Start());
       src_server = https_src_server.get();
     }
     GURL src_url = src_server->GetURL(replacement_path);
 
-    ASSERT_TRUE(prerender_manager());
-    prerender_manager()->mutable_config().rate_limit_enabled = false;
-    prerender_manager()->mutable_config().https_allowed = true;
+    ASSERT_TRUE(GetPrerenderManager());

[dominich, 2012/04/30 14:52:16]

consider caching the result of GetPrerenderManager in a local variable.

+    GetPrerenderManager()->mutable_config().rate_limit_enabled = false;
+    GetPrerenderManager()->mutable_config().https_allowed = true;
     ASSERT_TRUE(prerender_contents_factory_ == NULL);
     prerender_contents_factory_ =
         new WaitForLoadPrerenderContentsFactory(
             expected_number_of_loads,
             expected_final_status_queue,
             prerender_should_wait_for_ready_title);
-    prerender_manager()->SetPrerenderContentsFactory(
+    GetPrerenderManager()->SetPrerenderContentsFactory(
         prerender_contents_factory_);
     FinalStatus expected_final_status = expected_final_status_queue.front();
 
     // ui_test_utils::NavigateToURL uses its own observer and message loop.
     // Since the test needs to wait until the prerendered page has stopped
     // loading, rather than the page directly navigated to, need to
     // handle browser navigation directly.
     current_browser()->OpenURL(OpenURLParams(
         src_url, Referrer(), CURRENT_TAB, content::PAGE_TRANSITION_TYPED,
         false));
@@ skipping 23 matching lines @@
       // In the failure case, we should have removed |dest_url_| from the
       // prerender_manager.  We ignore dummy PrerenderContents (as indicated
       // by not having started).
       EXPECT_TRUE(prerender_contents == NULL ||
                   !prerender_contents->prerendering_has_started());
     }
   }
 
   void NavigateToURLImpl(const GURL& dest_url,
                          WindowOpenDisposition disposition) const {
-    ASSERT_TRUE(prerender_manager() != NULL);
+    ASSERT_TRUE(GetPrerenderManager() != NULL);
     // Make sure in navigating we have a URL to use in the PrerenderManager.
     ASSERT_TRUE(GetPrerenderContents() != NULL);
 
     // If opening the page in a background tab, it won't be shown when swapped
     // in.
     if (disposition == NEW_BACKGROUND_TAB)
       GetPrerenderContents()->set_should_be_shown(false);
 
     scoped_ptr<ui_test_utils::WindowedNotificationObserver> page_load_observer;
     WebContents* web_contents = NULL;
@@ skipping 442 matching lines @@
 
 // Checks that popups on a prerendered page cause cancellation.
 IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest, PrerenderPopup) {
   PrerenderTestURL("files/prerender/prerender_popup.html",
                    FINAL_STATUS_CREATE_NEW_WINDOW,
                    1);
 }
 
 // Checks that renderers using excessive memory will be terminated.
 IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest, PrerenderExcessiveMemory) {
-  ASSERT_TRUE(prerender_manager());
-  prerender_manager()->mutable_config().max_bytes = 30 * 1024 * 1024;
+  ASSERT_TRUE(GetPrerenderManager());
+  GetPrerenderManager()->mutable_config().max_bytes = 30 * 1024 * 1024;
   PrerenderTestURL("files/prerender/prerender_excessive_memory.html",
                    FINAL_STATUS_MEMORY_LIMIT_EXCEEDED,
                    1);
 }
 
 // Checks shutdown code while a prerender is active.
 IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest, PrerenderQuickQuit) {
   PrerenderTestURL("files/prerender/prerender_page.html",
                    FINAL_STATUS_APP_TERMINATING,
                    0);
@@ skipping 74 matching lines @@
   // Start with two resources.
   PrerenderTestURL("files/prerender/prerender_page.html", FINAL_STATUS_USED, 1);
 
   // One of the resources that has a WebContents associated with it should have
   // the Prerender prefix.
   const string16 prefix =
       l10n_util::GetStringFUTF16(IDS_TASK_MANAGER_PRERENDER_PREFIX, string16());
   string16 prerender_title;
   int num_prerender_tabs = 0;
 
-  for (int i = 0; i < model()->ResourceCount(); ++i) {
-    if (model()->GetResourceTabContents(i)) {
-      prerender_title = model()->GetResourceTitle(i);
+  for (int i = 0; i < GetModel()->ResourceCount(); ++i) {

[dominich, 2012/04/30 14:52:16]

consider caching the result of GetModel in a local (const?) variable.

+    if (GetModel()->GetResourceTabContents(i)) {
+      prerender_title = GetModel()->GetResourceTitle(i);
       if (StartsWith(prerender_title, prefix, true))
         ++num_prerender_tabs;
     }
   }
   EXPECT_EQ(1, num_prerender_tabs);
   const string16 prerender_page_title = prerender_title.substr(prefix.length());
 
   NavigateToDestURL();
 
   // There should be no tabs with the Prerender prefix.
   const string16 tab_prefix =
       l10n_util::GetStringFUTF16(IDS_TASK_MANAGER_TAB_PREFIX, string16());
   num_prerender_tabs = 0;
   int num_tabs_with_prerender_page_title = 0;
-  for (int i = 0; i < model()->ResourceCount(); ++i) {
-    if (model()->GetResourceTabContents(i)) {
-      string16 tab_title = model()->GetResourceTitle(i);
+  for (int i = 0; i < GetModel()->ResourceCount(); ++i) {
+    if (GetModel()->GetResourceTabContents(i)) {
+      string16 tab_title = GetModel()->GetResourceTitle(i);
       if (StartsWith(tab_title, prefix, true)) {
         ++num_prerender_tabs;
       } else {
         EXPECT_TRUE(StartsWith(tab_title, tab_prefix, true));
 
         // The prerender tab should now be a normal tab but the title should be
         // the same. Depending on timing, there may be more than one of these.
         const string16 tab_page_title = tab_title.substr(tab_prefix.length());
         if (prerender_page_title.compare(tab_page_title) == 0)
           ++num_tabs_with_prerender_page_title;
@@ skipping 531 matching lines @@
   EXPECT_EQ(1, GetHistoryLength());
 }
 
 IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest, PrerenderCancelAll) {
   PrerenderTestURL("files/prerender/prerender_page.html",
                    FINAL_STATUS_CANCELLED,
                    1);
   // Post a task to cancel all the prerenders.
   MessageLoop::current()->PostTask(
       FROM_HERE,
-      base::Bind(&CancelAllPrerenders, prerender_manager()));
+      base::Bind(&CancelAllPrerenders, GetPrerenderManager()));
   ui_test_utils::RunMessageLoop();
   EXPECT_TRUE(GetPrerenderContents() == NULL);
 }
 
 // Prerendering and history tests.
 // The prerendered page is navigated to in several ways [navigate via
 // omnibox, click on link, key-modified click to open in background tab, etc],
 // followed by a navigation to another page from the prerendered page, followed
 // by a back navigation.
 
@@ skipping 134 matching lines @@
   WebContents* web_contents = browser()->GetSelectedWebContents();
   bool display_test_result = false;
   ASSERT_TRUE(ui_test_utils::ExecuteJavaScriptAndExtractBool(
       web_contents->GetRenderViewHost(), L"",
       L"DidDisplayReallyPass()",
       &display_test_result));
   ASSERT_TRUE(display_test_result);
 }
 
 }  // namespace prerender