Have tld_cleanup generate a .cc file that contains the effective

net/base/registry_controlled_domain.cc

 //* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
 /* ***** BEGIN LICENSE BLOCK *****
  * Version: MPL 1.1/GPL 2.0/LGPL 2.1
  *
  * The contents of this file are subject to the Mozilla Public License Version
  * 1.1 (the "License"); you may not use this file except in compliance with
  * the License. You may obtain a copy of the License at
  * http://www.mozilla.org/MPL/
  *
  * Software distributed under the License is distributed on an "AS IS" basis,
@@ skipping 29 matching lines @@
 #include "net/base/registry_controlled_domain.h"
 
 #include "base/logging.h"
 #include "base/singleton.h"
 #include "base/string_util.h"
 #include "googleurl/src/gurl.h"
 #include "googleurl/src/url_parse.h"
 #include "net/base/net_module.h"
 #include "net/base/net_util.h"
 
-#if !defined(OS_MACOSX)
-#include "net_resources.h"
-#endif
-
 namespace net {
 
-// This list of rules is used by unit tests and any other time that the main
-// resource file is not available.  It should be kept exceedingly short to
-// avoid impacting unit test performance.
-static const char kDefaultDomainData[] = "com\n"
-                                         "edu\n"
-                                         "gov\n"
-                                         "net\n"
-                                         "org\n"
-                                         "co.uk\n";
-
 // static
 std::string RegistryControlledDomainService::GetDomainAndRegistry(
     const GURL& gurl) {
   const url_parse::Component host =
       gurl.parsed_for_possibly_invalid_spec().host;
   if ((host.len <= 0) || gurl.HostIsIPAddress())
     return std::string();
   return GetDomainAndRegistryImpl(std::string(
       gurl.possibly_invalid_spec().data() + host.begin, host.len));
 }
@@ skipping 204 matching lines @@
 }
 
 // static
 void RegistryControlledDomainService::UseDomainData(const std::string& data) {
   RegistryControlledDomainService* instance = GetInstance();
   instance->copied_domain_data_ = data;
   instance->ParseDomainData(instance->copied_domain_data_);
 }
 
 void RegistryControlledDomainService::Init() {
-#if defined(OS_MACOSX)
-  ParseDomainData(kDefaultDomainData);
-#else
-  // The resource file isn't present for some unit tests, for example.  Fall
-  // back to a tiny, basic list of rules in that case.
-  StringPiece res_data = NetModule::GetResource(IDR_EFFECTIVE_TLD_NAMES);
-  ParseDomainData(!res_data.empty() ? res_data : kDefaultDomainData);
-#endif
+  ParseDomainData(kDomainData);
 }
 
 void RegistryControlledDomainService::ParseDomainData(const StringPiece& data) {
   domain_set_.clear();
 
   size_t line_end = 0;
   size_t line_start = 0;
   while (line_start < data.size()) {
     line_end = data.find('\n', line_start);
     if (line_end == StringPiece::npos)
@@ skipping 22 matching lines @@
     // and an exception (ex *.google.com and !google.com).  Sets are immutable,
     // we'll erase the old one, and insert a new one with the new attributes.
     rule.attributes.Combine(prev_rule->attributes);
     domain_set_.erase(prev_rule);
   }
 
   domain_set_.insert(rule);
 }
 
 }  // namespace net