CommandLine Page Cycler

chrome/browser/page_cycler/page_cycler.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 "chrome/browser/page_cycler/page_cycler.h"
+
+#include "base/bind.h"
+#include "base/file_path.h"
+#include "base/file_util.h"
+#include "base/message_loop.h"
+#include "base/process_util.h"
+#include "base/string_split.h"
+#include "base/string_number_conversions.h"
+#include "base/utf_string_conversions.h"
+#include "chrome/common/chrome_notification_types.h"
+#include "chrome/test/base/chrome_process_util.h"
+#include "chrome/test/perf/perf_test.h"
+#include "content/public/browser/browser_thread.h"
+#include "content/public/browser/notification_source.h"
+#include "content/public/browser/notification_service.h"
+#include "content/public/browser/notification_details.h"
+#include "content/public/browser/notification_types.h"
+#include "content/public/browser/web_contents.h"
+#include "content/public/common/url_constants.h"
+
+using content::NavigationController;
+using content::OpenURLParams;
+using content::Referrer;
+using content::WebContents;
+
+PageCycler::PageCycler(Browser* browser,
+                       FilePath urls_file,
+                       FilePath errors_file)
+    : content::WebContentsObserver(browser->GetSelectedWebContents()),
+      browser_(browser),
+      urls_file_(urls_file),
+      errors_file_(errors_file),
+      url_index_(0),
+      iterations_(0) {
+  Init();
+}
+
+PageCycler::PageCycler(Browser* browser,
+                       FilePath urls_file,
+                       FilePath errors_file,
+                       FilePath stats_file)
+    : content::WebContentsObserver(browser->GetSelectedWebContents()),
+      browser_(browser),
+      urls_file_(urls_file),
+      errors_file_(errors_file),
+      stats_file_(stats_file),
+      url_index_(0),
+      iterations_(0) {
+  Init();
+}
+
+PageCycler::~PageCycler() {
+}
+
+void PageCycler::Init() {
+  BrowserList::AddObserver(this);
+  AddRef();  // Balanced in Finish()/Abort() (only one should be called).
+}
+
+void PageCycler::DidFinishLoad(int64 frame_id,
+                               const GURL& validated_url,
+                               bool is_main_frame) {
+  // In the event of certain load failures, chrome will load the error page
+  // kUnreachableWebDataURL. We do not want to count this as a load success or
+  // failure, because it will throw off the count.
+  if (is_main_frame && validated_url.spec() != chrome::kUnreachableWebDataURL)

[Aaron Boodman, 2012/03/20 19:28:16]

Man, that is a bummer. It would be easy for code elsewhere in Chrome to change
and for this to stop working. I don't have a suggestion for improvement though.

+    LoadSucceeded();
+}
+
+void PageCycler::DidFailProvisionalLoad(int64 frame_id,
+                                        bool is_main_frame,
+                                        const GURL& validated_url,
+                                        int error_code,
+                                        const string16& error_description) {
+  // In the event of certain load failures, chrome will load the error page
+  // kUnreachableWebDataURL. We do not want to count this as a load success or
+  // failure, because it will throw off the count.
+  if (is_main_frame && validated_url.spec() != chrome::kUnreachableWebDataURL)
+    LoadFailed(validated_url, error_description);
+}
+
+void PageCycler::Run(unsigned int iterations) {
+  iterations_ = iterations;
+  content::BrowserThread::PostBlockingPoolTask(
+      FROM_HERE,
+      base::Bind(&PageCycler::ReadURLsOnBackgroundThread, this));
+}
+
+void PageCycler::ReadURLsOnBackgroundThread() {
+  CHECK(!content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
+  std::string file_contents;
+  std::vector<std::string> url_strings;
+
+  CHECK(file_util::PathExists(urls_file_));
+  file_util::ReadFileToString(urls_file_, &file_contents);
+  base::SplitStringAlongWhitespace(file_contents, &url_strings);
+
+  if (!url_strings.size())
+    DLOG(WARNING) << "Page Cycler: No URLs in given file: " <<
+        urls_file_.value();
+
+  for (std::vector<std::string>::const_iterator iter = url_strings.begin();
+       iter != url_strings.end(); ++iter) {
+    // Since we don't count kUnreachableWebData as a valid load, we don't want
+    // the user to specify this as one of the pages to visit.
+    if (*iter == chrome::kUnreachableWebDataURL) {
+      DLOG(WARNING) << "Chrome error pages are not allowed as urls." <<
+          "Omitting url: " << *iter << ".";
+    } else {
+      urls_.push_back(GURL(*iter));
+    }
+  }
+
+  content::BrowserThread::PostTask(content::BrowserThread::UI,
+                                   FROM_HERE,
+                                   base::Bind(&PageCycler::BeginCycle, this));
+}
+
+void PageCycler::BeginCycle() {
+  CHECK(iterations_);
+  --iterations_;
+  CHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
+
+  // Upon launch, Chrome will automatically load the newtab page. This results
+  // in the browser most likely (but not definitely) being in a state of loading
+  // when PageCycler is ready to start. If we load the next URL when it is
+  // already trying to load, this will result in a page-load error for the
+  // previous URL (in this case, newtab); this will call LoadFailed(), and the
+  // first page of the url list will be skipped. If we are loading, we wait for
+  // the load to finish, which will then call LoadSucceeded() or LoadFailed(),
+  // and subsequently call LoadNextURL(). If we are not loading, we are safe to
+  // begin the cycle now.
+  if (browser_->GetSelectedWebContents()->IsLoading())
+    return;
+
+  LoadNextURL();
+}
+
+void PageCycler::LoadNextURL() {
+  CHECK(browser_);
+  if (url_index_ >= urls_.size()) {
+    if (iterations_) {
+      url_index_ = 0;
+      BeginCycle();
+      return;
+    } else {
+      PrepareResults();
+      return;
+    }
+  }
+
+  if (url_index_) {
+    timings_string_.append(", ");
+    urls_string_.append(", ");
+  }
+  urls_string_.append(urls_[url_index_].spec());
+  initial_time_ = base::TimeTicks::HighResNow();
+  OpenURLParams params(urls_[url_index_],
+                       Referrer(),
+                       CURRENT_TAB,
+                       content::PAGE_TRANSITION_TYPED,
+                       false);
+  ++url_index_;
+  browser_->OpenURL(params);
+}
+
+void PageCycler::LoadSucceeded() {
+  base::TimeDelta time_elapsed =
+      (base::TimeTicks::HighResNow() - initial_time_) / 1000.0;
+  timings_string_.append(base::Int64ToString(time_elapsed.ToInternalValue()));
+  LoadNextURL();
+}
+
+void PageCycler::LoadFailed(const GURL& url,
+                            const string16& error_description) {
+  error_.append(ASCIIToUTF16("Failed to load the page at: " +
+      url.spec() + ": ")).append(error_description).
+      append(ASCIIToUTF16("\n"));
+  LoadNextURL();
+}
+
+void PageCycler::PrepareResults() {
+  std::string output;
+  if (!stats_file_.empty()) {
+    base::ProcessId pid = base::GetParentProcessId(base::GetCurrentProcId());
+    ChromeProcessList chrome_processes(GetRunningChromeProcesses(pid));
+    output += perf_test::MemoryUsageInfoToString("", chrome_processes, pid);
+    output += perf_test::IOPerfInfoToString("", chrome_processes, pid);
+    output += perf_test::SystemCommitChargeToString("",
+              base::GetSystemCommitCharge(), false);
+    output.append("Pages: [" + urls_string_ + "]\n");
+    output.append("*RESULT times: t_ref= [" + timings_string_ + "] ms\n");
+  }
+  content::BrowserThread::PostBlockingPoolTask(
+      FROM_HERE,
+      base::Bind(&PageCycler::WriteResultsOnBackgroundThread, this, output));
+}
+
+void PageCycler::WriteResultsOnBackgroundThread(std::string output) {
+  CHECK(!content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
+  if (!output.empty()) {
+    CHECK(!stats_file_.empty());
+    file_util::WriteFile(stats_file_, output.c_str(), output.size());
+  }
+  CHECK(!errors_file_.empty());
+  if (!error_.empty()) {
+    file_util::WriteFile(errors_file_, UTF16ToUTF8(error_).c_str(),
+                         error_.size());
+  } else if (file_util::PathExists(errors_file_)) {
+    // If there is an old error file, delete it to avoid confusion.
+    file_util::Delete(errors_file_, false);
+  }
+  content::BrowserThread::PostTask(content::BrowserThread::UI,
+                                   FROM_HERE,
+                                   base::Bind(&PageCycler::Finish, this));
+}
+
+void PageCycler::Finish() {
+  CHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
+  BrowserList::RemoveObserver(this);
+  browser_->Exit();
+  Release();  // Balanced in Init() (only one of Finish/Abort should be called).
+}
+
+void PageCycler::Abort() {
+  browser_ = NULL;
+  BrowserList::RemoveObserver(this);
+  Release();  // Balanced in Init() (only one of Finish/Abort should be called).
+}
+
+void PageCycler::OnBrowserAdded(const Browser* browser) {}
+
+void PageCycler::OnBrowserRemoved(const Browser* browser) {
+  if (browser == browser_) {
+    DLOG(WARNING) <<
+        "Page Cycler: browser was closed before the run was completed.";
+    MessageLoop::current()->PostTask(FROM_HERE,
+                                     base::Bind(&PageCycler::Abort, this));
+  }
+}