Rename domain_security_preload_generator.

net/tools/transport_security_state_generator/trie/trie_writer.cc

 // Copyright (c) 2016 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/domain_security_preload_generator/trie/trie_writer.h"
+#include "net/tools/transport_security_state_generator/trie/trie_writer.h"
 
 #include <algorithm>
 
 #include "base/logging.h"
 #include "base/strings/string_piece.h"
 #include "base/strings/string_split.h"
 #include "base/strings/string_util.h"
-#include "net/tools/domain_security_preload_generator/trie/trie_bit_buffer.h"
+#include "net/tools/transport_security_state_generator/trie/trie_bit_buffer.h"
 
 namespace net {
 
 namespace transport_security_state {
 
 namespace {
 
 bool CompareReversedEntries(const std::unique_ptr<ReversedEntry>& lhs,
                             const std::unique_ptr<ReversedEntry>& rhs) {
   return lhs->reversed_name < rhs->reversed_name;
@@ skipping 13 matching lines @@
 
   std::string domain = base::ToUpperASCII(parts[parts.size() - 2].as_string());
   base::ReplaceChars(domain, "-", "_", &domain);
 
   return base::ToUpperASCII(domain + "_" + gtld);
 }
 
 }  // namespace
 
 ReversedEntry::ReversedEntry(std::vector<uint8_t> reversed_name,
-                             const DomainSecurityEntry* entry)
+                             const TransportSecurityStateEntry* entry)
     : reversed_name(reversed_name), entry(entry) {}
 
 ReversedEntry::~ReversedEntry() {}
 
 TrieWriter::TrieWriter(const HuffmanRepresentationTable& huffman_table,
                        const NameIDMap& domain_ids_map,
                        const NameIDMap& expect_ct_report_uri_map,
                        const NameIDMap& expect_staple_report_uri_map,
                        const NameIDMap& pinsets_map,
-                       HuffmanFrequencyTracker* frequency_tracker)
+                       HuffmanBuilder* huffman_builder)
     : huffman_table_(huffman_table),
       domain_ids_map_(domain_ids_map),
       expect_ct_report_uri_map_(expect_ct_report_uri_map),
       expect_staple_report_uri_map_(expect_staple_report_uri_map),
       pinsets_map_(pinsets_map),
-      frequency_tracker_(frequency_tracker) {}
+      huffman_builder_(huffman_builder) {}
 
 TrieWriter::~TrieWriter() {}
 
-uint32_t TrieWriter::WriteEntries(const DomainSecurityEntries& entries) {
+uint32_t TrieWriter::WriteEntries(
+    const TransportSecurityStateEntries& entries) {
   ReversedEntries reversed_entries;
 
   for (auto const& entry : entries) {
     std::unique_ptr<ReversedEntry> reversed_entry(
         new ReversedEntry(ReverseName(entry->hostname), entry.get()));
     reversed_entries.push_back(std::move(reversed_entry));
   }
 
   std::stable_sort(reversed_entries.begin(), reversed_entries.end(),
                    CompareReversedEntries);
 
   return WriteDispatchTables(reversed_entries.begin(), reversed_entries.end());
 }
 
 uint32_t TrieWriter::WriteDispatchTables(ReversedEntries::iterator start,
                                          ReversedEntries::iterator end) {
   DCHECK(start != end) << "No entries passed to WriteDispatchTables";
 
   TrieBitBuffer writer;
 
   std::vector<uint8_t> prefix = LongestCommonPrefix(start, end);
   for (size_t i = 0; i < prefix.size(); ++i) {
     writer.WriteBit(1);
   }
   writer.WriteBit(0);
 
   if (prefix.size()) {
     for (size_t i = 0; i < prefix.size(); ++i) {
-      writer.WriteChar(prefix.at(i), huffman_table_, frequency_tracker_);
+      writer.WriteChar(prefix.at(i), huffman_table_, huffman_builder_);
     }
   }
 
   RemovePrefix(prefix.size(), start, end);
   int32_t last_position = -1;
 
   while (start != end) {
     uint8_t candidate = (*start)->reversed_name.at(0);
     ReversedEntries::iterator sub_entries_end = start + 1;
 
     for (; sub_entries_end != end; sub_entries_end++) {
       if ((*sub_entries_end)->reversed_name.at(0) != candidate) {
         break;
       }
     }
 
-    writer.WriteChar(candidate, huffman_table_, frequency_tracker_);
+    writer.WriteChar(candidate, huffman_table_, huffman_builder_);
 
     if (candidate == kTerminalValue) {
       DCHECK((sub_entries_end - start) == 1)
           << "Multiple values with the same name";
-      WriteSecurityEntry((*start)->entry, &writer);
+      WriteEntry((*start)->entry, &writer);
     } else {
       RemovePrefix(1, start, sub_entries_end);
       uint32_t position = WriteDispatchTables(start, sub_entries_end);
       writer.WritePosition(position, &last_position);
     }
 
     start = sub_entries_end;
   }
 
-  writer.WriteChar(kEndOfTableValue, huffman_table_, frequency_tracker_);
+  writer.WriteChar(kEndOfTableValue, huffman_table_, huffman_builder_);
 
   uint32_t position = buffer_.position();
   writer.Flush();
   writer.WriteToBitWriter(&buffer_);
   return position;
 }
 
-void TrieWriter::WriteSecurityEntry(const DomainSecurityEntry* entry,
-                                    TrieBitBuffer* writer) {
+void TrieWriter::WriteEntry(const TransportSecurityStateEntry* entry,
+                            TrieBitBuffer* writer) {
   uint8_t include_subdomains = 0;
   if (entry->include_subdomains) {
     include_subdomains = 1;
   }
   writer->WriteBit(include_subdomains);
 
   uint8_t force_https = 0;
   if (entry->force_https) {
     force_https = 1;
   }
@@ skipping 126 matching lines @@
   return buffer_.position();
 }
 
 void TrieWriter::Flush() {
   buffer_.Flush();
 }
 
 }  // namespace transport_security_state
 
 }  // namespace net