Clang format slam.

net/tools/tld_cleanup/tld_cleanup_util.cc

 // Copyright 2013 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 "net/tools/tld_cleanup/tld_cleanup_util.h"
 
 #include "base/file_util.h"
 #include "base/logging.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_util.h"
@@ skipping 11 matching lines @@
 }
 
 namespace net {
 namespace tld_cleanup {
 
 // 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 RuleMap& rules, const base::FilePath& outfile) {
   std::string data;
-  data.append("%{\n"
-              "// Copyright 2012 The Chromium Authors. All rights reserved.\n"
-              "// Use of this source code is governed by a BSD-style license "
-              "that can be\n"
-              "// found in the LICENSE file.\n\n"
-              "// This file is generated by net/tools/tld_cleanup/.\n"
-              "// DO NOT MANUALLY EDIT!\n"
-              "%}\n"
-              "struct DomainRule {\n"
-              "  int name_offset;\n"
-              "  int type;  // flags: 1: exception, 2: wildcard, 4: private\n"
-              "};\n"
-              "%%\n");
+  data.append(
+      "%{\n"
+      "// Copyright 2012 The Chromium Authors. All rights reserved.\n"
+      "// Use of this source code is governed by a BSD-style license "
+      "that can be\n"
+      "// found in the LICENSE file.\n\n"
+      "// This file is generated by net/tools/tld_cleanup/.\n"
+      "// DO NOT MANUALLY EDIT!\n"
+      "%}\n"
+      "struct DomainRule {\n"
+      "  int name_offset;\n"
+      "  int type;  // flags: 1: exception, 2: wildcard, 4: private\n"
+      "};\n"
+      "%%\n");
 
   for (RuleMap::const_iterator i = rules.begin(); i != rules.end(); ++i) {
     data.append(i->first);
     data.append(", ");
     int type = 0;
     if (i->second.exception) {
       type = kExceptionRule;
     } else if (i->second.wildcard) {
       type = kWildcardRule;
     }
     if (i->second.is_private) {
       type += kPrivateRule;
     }
     data.append(base::IntToString(type));
     data.append("\n");
   }
 
   data.append("%%\n");
 
-  int written = base::WriteFile(outfile,
-                                     data.data(),
-                                     static_cast<int>(data.size()));
+  int written =
+      base::WriteFile(outfile, data.data(), static_cast<int>(data.size()));
 
   return written == static_cast<int>(data.size());
 }
 
 // Adjusts the rule to a standard form: removes single extraneous dots and
 // canonicalizes it using GURL. Returns kSuccess if the rule is interpreted as
 // valid; logs a warning and returns kWarning if it is probably invalid; and
 // logs an error and returns kError if the rule is (almost) certainly invalid.
 NormalizeResult NormalizeRule(std::string* domain, Rule* rule) {
   NormalizeResult result = kSuccess;
@@ skipping 45 matching lines @@
   }
   if (!gurl.is_valid()) {
     LOG(WARNING) << "Keeping rule that GURL says is invalid: " << *domain;
     result = kWarning;
   }
   domain->assign(spec.substr(host.begin, host.len));
 
   return result;
 }
 
-NormalizeResult NormalizeDataToRuleMap(const std::string data,
-                                       RuleMap* rules) {
+NormalizeResult NormalizeDataToRuleMap(const std::string data, RuleMap* rules) {
   CHECK(rules);
   // We do a lot of string assignment during parsing, but simplicity is more
   // important than performance here.
   std::string domain;
   NormalizeResult result = kSuccess;
   size_t line_start = 0;
   size_t line_end = 0;
   bool is_private = false;
   RuleMap extra_rules;
   int begin_private_length = arraysize(kBeginPrivateDomainsComment) - 1;
   int end_private_length = arraysize(kEndPrivateDomainsComment) - 1;
   while (line_start < data.size()) {
     if (line_start + begin_private_length < data.size() &&
-        !data.compare(line_start, begin_private_length,
-                      kBeginPrivateDomainsComment)) {
+        !data.compare(
+            line_start, begin_private_length, kBeginPrivateDomainsComment)) {
       is_private = true;
       line_end = line_start + begin_private_length;
     } else if (line_start + end_private_length < data.size() &&
-        !data.compare(line_start, end_private_length,
-                      kEndPrivateDomainsComment)) {
+               !data.compare(
+                   line_start, end_private_length, kEndPrivateDomainsComment)) {
       is_private = false;
       line_end = line_start + end_private_length;
-    } else if (line_start + 1 < data.size() &&
-        data[line_start] == '/' &&
-        data[line_start + 1] == '/') {
+    } else if (line_start + 1 < data.size() && data[line_start] == '/' &&
+               data[line_start + 1] == '/') {
       // Skip comments.
       line_end = data.find_first_of("\r\n", line_start);
       if (line_end == std::string::npos)
         line_end = data.size();
     } else {
       // Truncate at first whitespace.
       line_end = data.find_first_of("\r\n \t", line_start);
       if (line_end == std::string::npos)
         line_end = data.size();
       domain.assign(data.data(), line_start, line_end - line_start);
@@ skipping 74 matching lines @@
   NormalizeResult result = NormalizeDataToRuleMap(data, &rules);
 
   if (!WriteRules(rules, out_filename)) {
     LOG(ERROR) << "Error(s) writing output file";
     result = kError;
   }
 
   return result;
 }
 
-
 }  // namespace tld_cleanup
 }  // namespace net