Have tld_cleanup generate a .cc file that contains the effective

net/tools/tld_cleanup/tld_cleanup.cc

 // Copyright (c) 2006-2008 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.
 
 // This command-line program converts an effective-TLD data file in UTF-8 from
 // the format provided by Mozilla to the format expected by Chrome.  Any errors
 // or warnings are recorded in tld_cleanup.log.
 //
 // In particular, it
 //  * Strips blank lines and comments, as well as notes for individual rules.
@@ skipping 20 matching lines @@
 #include "googleurl/src/gurl.h"
 #include "googleurl/src/url_parse.h"
 
 typedef std::set<std::string> StringSet;
 
 // Writes the list of domain rules contained in the 'rules' set to the
 // 'outfile', with each rule terminated by a LF.  The file must already have
 // been created with write access.
 bool WriteRules(const StringSet& rules, FilePath outfile) {
   std::string data;
+  data.append(
+      "// Copyright (c) 2009 The Chromium Authors. All rights reserved.\n"
+      "// Use of this source code is governed by a BSD-style license that\n"
+      "// can be found in the LICENSE file.\n\n"
+      "// This file is generated by net/tools/tld_cleanup/.\n"
+      "// DO NOT MANUALLY EDIT!\n"
+      "#include \"net/base/registry_controlled_domain.h\"\n\n"
+      "const char net::RegistryControlledDomainService::kDomainData[] =\n"
+  );
+
   for (StringSet::const_iterator iter = rules.begin();
        iter != rules.end();
        ++iter) {
+    data.append("  \"");
     data.append(*iter);
-    data.append("\n");
+    data.append("\\n\"\n");
   }
 
+  data.append(";\n");
+
   int written = file_util::WriteFile(outfile.ToWStringHack(), data.data(),
                                      data.size());
 
   return written == static_cast<int>(data.size());
 }
 
 // These result codes should be in increasing order of severity.
 typedef enum {
   kSuccess,
   kWarning,
@@ skipping 65 matching lines @@
     rule->insert(0, 1, '!');
   else if (wildcard)
     rule->insert(0, "*.");
 
   return result;
 }
 
 // Loads the file described by 'in_filename', converts it to the desired format
 // (see the file comments above), and saves it into 'out_filename'.  Returns
 // the most severe of the result codes encountered when normalizing the rules.
-NormalizeResult NormalizeFile(const std::wstring& in_filename,
-                              const std::wstring& out_filename) {
+NormalizeResult NormalizeFile(const FilePath& in_filename,
+                              const FilePath& out_filename) {
   std::string data;
   if (!file_util::ReadFileToString(in_filename, &data)) {
-    fwprintf(stderr, L"Unable to read file %ls\n", in_filename.c_str());
+    LOG(ERROR) << "Unable to read file";
     // We return success since we've already reported the error.
     return kSuccess;
   }
 
   // We do a lot of string assignment during parsing, but simplicity is more
   // important than performance here.
   std::string rule;
   NormalizeResult result = kSuccess;
   size_t line_start = 0;
   size_t line_end = 0;
@@ skipping 26 matching lines @@
 
     // Find beginning of next non-empty line.
     line_start = data.find_first_of("\r\n", line_end);
     if (line_start == std::string::npos)
       line_start = data.size();
     line_start = data.find_first_not_of("\r\n", line_start);
     if (line_start == std::string::npos)
       line_start = data.size();
   }
 
-  if (!WriteRules(rules, FilePath::FromWStringHack(out_filename))) {
-    LOG(ERROR) << "Error(s) writing " << out_filename;
+  if (!WriteRules(rules, out_filename)) {
+    LOG(ERROR) << "Error(s) writing output file";
     result = kError;
   }
 
   return result;
 }
 
 int main(int argc, const char* argv[]) {
   base::EnableTerminationOnHeapCorruption();
-  if (argc != 3) {
+  if (argc != 1) {
     fprintf(stderr, "Normalizes and verifies UTF-8 TLD data files\n");
-    fprintf(stderr, "Usage: %s <input> <output>\n", argv[0]);
+    fprintf(stderr, "Usage: %s\n", argv[0]);
     return 1;
   }
 
   // Manages the destruction of singletons.
   base::AtExitManager exit_manager;
 
   // Only use OutputDebugString in debug mode.
 #ifdef NDEBUG
   logging::LoggingDestination destination = logging::LOG_ONLY_TO_FILE;
 #else
   logging::LoggingDestination destination =
       logging::LOG_TO_BOTH_FILE_AND_SYSTEM_DEBUG_LOG;
 #endif
 
   CommandLine::Init(argc, argv);
 
   FilePath log_filename;
   PathService::Get(base::DIR_EXE, &log_filename);
   log_filename = log_filename.AppendASCII("tld_cleanup.log");
   logging::InitLogging(log_filename.value().c_str(),
                        destination,
                        logging::LOCK_LOG_FILE,
                        logging::DELETE_OLD_LOG_FILE);
 
   icu_util::Initialize();
 
-  NormalizeResult result = NormalizeFile(UTF8ToWide(argv[1]),
-                                         UTF8ToWide(argv[2]));
+  FilePath input_file;
+  PathService::Get(base::DIR_SOURCE_ROOT, &input_file);
+  input_file = input_file.Append(FILE_PATH_LITERAL("net"))
+                         .Append(FILE_PATH_LITERAL("base"))
+                         .Append(FILE_PATH_LITERAL("effective_tld_names.dat"));
+  FilePath output_file;
+  PathService::Get(base::DIR_SOURCE_ROOT, &output_file);
+  output_file = output_file.Append(FILE_PATH_LITERAL("net"))
+                           .Append(FILE_PATH_LITERAL("base"))
+                           .Append(FILE_PATH_LITERAL("effective_tld_names.cc"));
+  NormalizeResult result = NormalizeFile(input_file, output_file);
   if (result != kSuccess) {
     fprintf(stderr,
             "Errors or warnings processing file.  See log in tld_cleanup.log.");
   }
 
   if (result == kError)
     return 1;
   return 0;
 }