Run the JSON Schema Compiler's bundle compilation on JSON files. Previously it

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_;
 }
 
-// CaptureURLsFunction  ------------------------------------------------
+// RecordCaptureURLsFunction  ------------------------------------------------
 
-CaptureURLsFunction::CaptureURLsFunction()
+RecordCaptureURLsFunction::RecordCaptureURLsFunction()
     : RunPageCyclerFunction(new ProductionProcessStrategy()) {}
 
-CaptureURLsFunction::CaptureURLsFunction(ProcessStrategy* strategy)
+RecordCaptureURLsFunction::RecordCaptureURLsFunction(ProcessStrategy* strategy)
     : RunPageCyclerFunction(strategy) {}
 
 // Fetch data for possible optional switch for an extension to load.
-bool CaptureURLsFunction::ParseJSParameters() {
+bool RecordCaptureURLsFunction::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;
 }
 
-// CaptureURLsFunction adds "record-mode" to sub-browser call, and returns
+// RecordCaptureURLsFunction adds "record-mode" to sub-browser call, and returns
 // just the (possibly empty) error list.
-void CaptureURLsFunction::AddSwitches(CommandLine* line) {
+void RecordCaptureURLsFunction::AddSwitches(CommandLine* line) {
   if (!line->HasSwitch(switches::kRecordMode))
     line->AppendSwitch(switches::kRecordMode);
 }
 
-void CaptureURLsFunction::Finish() {
+void RecordCaptureURLsFunction::Finish() {
   results_ = record::CaptureURLs::Results::Create(errors_);
   SendResponse(true);
 }
 
-// ReplayURLsFunction ------------------------------------------------
+// RecordReplayURLsFunction ------------------------------------------------
 
-ReplayURLsFunction::ReplayURLsFunction()
+RecordReplayURLsFunction::RecordReplayURLsFunction()
     : RunPageCyclerFunction(new ProductionProcessStrategy()),
     run_time_ms_(0.0) {
 }
 
-ReplayURLsFunction::ReplayURLsFunction(ProcessStrategy* strategy)
+RecordReplayURLsFunction::RecordReplayURLsFunction(ProcessStrategy* strategy)
     : RunPageCyclerFunction(strategy), run_time_ms_(0.0) {
 }
 
-ReplayURLsFunction::~ReplayURLsFunction() {}
+RecordReplayURLsFunction::~RecordReplayURLsFunction() {}
 
 // Fetch data for possible optional switches for a repeat count and an
 // extension to load.
-bool ReplayURLsFunction::ParseJSParameters() {
+bool RecordReplayURLsFunction::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 ReplayURLsFunction::AddSwitches(CommandLine* line) {
+void RecordReplayURLsFunction::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 ReplayURLsFunction::ReadReplyFiles() {
+void RecordReplayURLsFunction::ReadReplyFiles() {
   file_util::ReadFileToString(stats_file_path_, &stats_);
 
   run_time_ms_ = (base::Time::NowFromSystemTime() - timer_).InMillisecondsF();
 }
 
-void ReplayURLsFunction::Finish() {
+void RecordReplayURLsFunction::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