Revert 176015

chrome/browser/extensions/api/record/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/api/record/record_api.h"
 
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/file_util.h"
 #include "base/logging.h"
@@ skipping 134 matching lines @@
 
   // Back to UI thread to finish up the JS call.
   content::BrowserThread::PostTask(content::BrowserThread::UI, FROM_HERE,
       base::Bind(&RunPageCyclerFunction::Finish, this));
 }
 
 const ProcessStrategy &RunPageCyclerFunction::GetProcessStrategy() {
   return *process_strategy_;
 }
 
-// RecordCaptureURLsFunction  ------------------------------------------------
+// CaptureURLsFunction  ------------------------------------------------
 
-RecordCaptureURLsFunction::RecordCaptureURLsFunction()
+CaptureURLsFunction::CaptureURLsFunction()
     : RunPageCyclerFunction(new ProductionProcessStrategy()) {}
 
-RecordCaptureURLsFunction::RecordCaptureURLsFunction(ProcessStrategy* strategy)
+CaptureURLsFunction::CaptureURLsFunction(ProcessStrategy* strategy)
     : RunPageCyclerFunction(strategy) {}
 
 // Fetch data for possible optional switch for an extension to load.
-bool RecordCaptureURLsFunction::ParseJSParameters() {
+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');
   // TODO(cstaley): Can't just use captureName -- gotta stick it in a temp dir.
   // TODO(cstaley): Ensure that capture name is suitable as directory name.
   user_data_dir_ = FilePath::FromUTF8Unsafe(params->capture_name);
 
   return true;
 }
 
-// RecordCaptureURLsFunction adds "record-mode" to sub-browser call, and returns
+// CaptureURLsFunction adds "record-mode" to sub-browser call, and returns
 // just the (possibly empty) error list.
-void RecordCaptureURLsFunction::AddSwitches(CommandLine* line) {
+void CaptureURLsFunction::AddSwitches(CommandLine* line) {
   if (!line->HasSwitch(switches::kRecordMode))
     line->AppendSwitch(switches::kRecordMode);
 }
 
-void RecordCaptureURLsFunction::Finish() {
+void CaptureURLsFunction::Finish() {
   results_ = record::CaptureURLs::Results::Create(errors_);
   SendResponse(true);
 }
 
-// RecordReplayURLsFunction ------------------------------------------------
+// ReplayURLsFunction ------------------------------------------------
 
-RecordReplayURLsFunction::RecordReplayURLsFunction()
+ReplayURLsFunction::ReplayURLsFunction()
     : RunPageCyclerFunction(new ProductionProcessStrategy()),
     run_time_ms_(0.0) {
 }
 
-RecordReplayURLsFunction::RecordReplayURLsFunction(ProcessStrategy* strategy)
+ReplayURLsFunction::ReplayURLsFunction(ProcessStrategy* strategy)
     : RunPageCyclerFunction(strategy), run_time_ms_(0.0) {
 }
 
-RecordReplayURLsFunction::~RecordReplayURLsFunction() {}
+ReplayURLsFunction::~ReplayURLsFunction() {}
 
 // Fetch data for possible optional switches for a repeat count and an
 // extension to load.
-bool RecordReplayURLsFunction::ParseJSParameters() {
+bool ReplayURLsFunction::ParseJSParameters() {
   scoped_ptr<record::ReplayURLs::Params> params(
       record::ReplayURLs::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params.get());
 
 
   // TODO(cstaley): Must build full temp dir from capture_name
   user_data_dir_ = FilePath::FromUTF8Unsafe(params->capture_name);
 
   // TODO(cstaley): Get this from user data dir ultimately
   url_contents_ = "http://www.google.com\nhttp://www.amazon.com";
 
   repeat_count_ = params->repeat_count;
 
   if (params->details.get()) {
     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
 // ParseJSParameters because file creation can't go on the UI thread.)
 // Plus, initialize time to create run time statistic.
-void RecordReplayURLsFunction::AddSwitches(CommandLine* line) {
+void ReplayURLsFunction::AddSwitches(CommandLine* line) {
   file_util::CreateTemporaryFile(&stats_file_path_);
 
   if (!extension_path_.empty())
     line->AppendSwitchPath(switches::kLoadExtension, extension_path_);
   line->AppendSwitch(switches::kPlaybackMode);
   line->AppendSwitchPath(switches::kRecordStats, stats_file_path_);
 
   timer_ = base::Time::NowFromSystemTime();
 }
 
 // Read stats file, and get run time.
-void RecordReplayURLsFunction::ReadReplyFiles() {
+void ReplayURLsFunction::ReadReplyFiles() {
   file_util::ReadFileToString(stats_file_path_, &stats_);
 
   run_time_ms_ = (base::Time::NowFromSystemTime() - timer_).InMillisecondsF();
 }
 
-void RecordReplayURLsFunction::Finish() {
+void ReplayURLsFunction::Finish() {
   record::ReplayURLsResult result;
 
   result.run_time = run_time_ms_;
   result.stats = stats_;
   result.errors = errors_;
 
   results_ = record::ReplayURLs::Results::Create(result);
   SendResponse(true);
 }
 
 } // namespace extensions