Record API fix adding FirstRun, and allowing repeat-count in capture (plus some browsertests along …

chrome/browser/extensions/extension_record_api.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/extensions/extension_record_api.h"
 
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/file_util.h"
 #include "base/logging.h"
 #include "base/memory/ref_counted.h"
 #include "base/process_util.h"
 #include "base/string_number_conversions.h"
 #include "base/string_split.h"
 #include "base/string_util.h"
 #include "base/utf_string_conversions.h"
 
 #include "chrome/common/chrome_switches.h"
 #include "chrome/common/extensions/api/experimental_record.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/common/content_switches.h"
 
 namespace record = extensions::api::experimental_record;
 
+const FilePath::CharType kFirstRunFile[] = FILE_PATH_LITERAL("First Run");
+
 ProcessStrategy::~ProcessStrategy() {}
 
 void ProductionProcessStrategy::RunProcess(const CommandLine& line) {
   base::LaunchOptions options;
 
   options.wait = true;
   base::LaunchProcess(line, options, NULL);
 }
 
 RunPageCyclerFunction::RunPageCyclerFunction(ProcessStrategy* strategy)
-    : base_command_line_(*CommandLine::ForCurrentProcess()),
+    : repeat_count_(1), base_command_line_(*CommandLine::ForCurrentProcess()),
     process_strategy_(strategy) {}
 
 RunPageCyclerFunction::~RunPageCyclerFunction() {}
 
 bool RunPageCyclerFunction::RunImpl() {
   if (!ParseJSParameters())
      return false;
 
   // If we've had any errors reportable to the JS caller so far (in
   // parameter parsing) then return a list of such errors, else perform
@@ skipping 43 matching lines @@
   remove_switches.push_back(switches::kVisitURLsCount);
   remove_switches.push_back(switches::kPlaybackMode);
   remove_switches.push_back(switches::kRecordStats);
   remove_switches.push_back(switches::kLoadExtension);
 
   CommandLine line = RemoveSwitches(base_command_line_, remove_switches);
 
   // Add the user-data-dir switch, since this is common to both call types.
   line.AppendSwitchPath(switches::kUserDataDir, user_data_dir_);
 
+  // Test browsers must run as if they are not in first-run mode, so if
+  // user_data_dir_ doesn't exist, create it and insert "First Run" file
+  line.AppendSwitch(switches::kNoFirstRun);
+
+  /*

[Aaron Boodman, 2012/06/05 04:17:04]

Kill dead code.

+  if (!file_util::PathExists(user_data_dir_)) {
+    file_util::CreateDirectory(user_data_dir_);
+    FilePath firstRunFilePath
+      = user_data_dir_.Append(FilePath::StringType(kFirstRunFile));
+    file_util::WriteFile(firstRunFilePath, "", 0);
+  }
+  */
+
   // Do the same for visit-urls, creating a temp file to communicate the
   // URL list to the test browser.
   FilePath url_path;
   file_util::CreateTemporaryFile(&url_path);
   file_util::WriteFile(url_path, url_contents_.c_str(), url_contents_.size());
   line.AppendSwitchPath(switches::kVisitURLs, url_path);
 
   // Set up Capture- or Replay-specific commandline switches.
   AddSwitches(&line);
   LOG(ERROR) << "Test browser commandline: " << line.GetCommandLineString();
@@ skipping 39 matching lines @@
 
 // Fetch data for possible optional switches for a repeat count and an
 // extension to load.
 bool CaptureURLsFunction::ParseJSParameters() {
   scoped_ptr<record::CaptureURLs::Params> params(
       record::CaptureURLs::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params.get());
 
   url_contents_ = JoinString(params->urls, '\n');
   user_data_dir_ = FilePath::FromUTF8Unsafe(params->cache_directory_path);
+  repeat_count_ = params->repeat_count;
 
   return true;
 }
 
 // CaptureURLsFunction adds "record-mode" to sub-browser call, and returns
 // just the (possibly empty) error list.
 void CaptureURLsFunction::AddSwitches(CommandLine* line) {
+  line->AppendSwitchASCII(switches::kVisitURLsCount,
+                          base::Int64ToString(repeat_count_));
+
   if (!line->HasSwitch(switches::kRecordMode))
     line->AppendSwitch(switches::kRecordMode);
 }
 
 void CaptureURLsFunction::Finish() {
   result_.reset(record::CaptureURLs::Result::Create(errors_));
   SendResponse(true);
 }
 
 
 // ReplayURLsFunction ------------------------------------------------
 
 ReplayURLsFunction::ReplayURLsFunction()
     : RunPageCyclerFunction(new ProductionProcessStrategy()),
-    repeat_count_(1), run_time_ms_(0) {
+    run_time_ms_(0) {
 }
 
 ReplayURLsFunction::ReplayURLsFunction(ProcessStrategy* strategy)
-    : RunPageCyclerFunction(strategy),
-    repeat_count_(1), run_time_ms_(0) {
+    : RunPageCyclerFunction(strategy), run_time_ms_(0) {
 }
 
 ReplayURLsFunction::~ReplayURLsFunction() {}
 
 // Fetch data for possible optional switches for a repeat count and an
 // extension to load.
 bool ReplayURLsFunction::ParseJSParameters() {
   scoped_ptr<record::ReplayURLs::Params> params(
       record::ReplayURLs::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params.get());
 
   url_contents_ = JoinString(params->urls, '\n');
   user_data_dir_ = FilePath::FromUTF8Unsafe(params->capture_directory_path);
+  repeat_count_ = params->repeat_count;
 
   if (params->details.get()) {
-    if (params->details->repeat_count.get())
-      repeat_count_ = *params->details->repeat_count;
     if (params->details->extension_path.get())
       extension_path_ =
           FilePath::FromUTF8Unsafe(*params->details->extension_path);
   }
 
   return true;
 }
 
 // Add special switches, if indicated, for repeat count and extension to load,
 // plus temp file into which to place stats. (Can't do this in
@@ skipping 23 matching lines @@
   record::ReplayURLsResult result;
 
   result.run_time = run_time_ms_;
   result.stats = stats_;
   result.errors = errors_;
 
   result_.reset(record::ReplayURLs::Result::Create(result));
   SendResponse(true);
 }