Add an option to print the resource ids that Chrome loads.

ui/base/resource/data_pack.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 "ui/base/resource/data_pack.h"
 
 #include <errno.h>
+#include <set>
 #include <utility>
 
+#include "base/command_line.h"
 #include "base/files/file_util.h"
 #include "base/files/memory_mapped_file.h"
 #include "base/logging.h"
 #include "base/memory/ptr_util.h"
 #include "base/memory/ref_counted_memory.h"
 #include "base/metrics/histogram_macros.h"
+#include "base/stl_util.h"
 #include "base/strings/string_piece.h"
 
 // For details of the file layout, see
 // http://dev.chromium.org/developers/design-documents/linuxresourcesandlocalizedstrings
 
 namespace {
 
 static const uint32_t kFileFormatVersion = 4;
 // Length of file header: version, entry count and text encoding type.
 static const size_t kHeaderLength = 2 * sizeof(uint32_t) + sizeof(uint8_t);
 
-#pragma pack(push,2)
+#pragma pack(push, 2)
 struct DataPackEntry {
   uint16_t resource_id;
   uint32_t file_offset;
 
   static int CompareById(const void* void_key, const void* void_entry) {
     uint16_t key = *reinterpret_cast<const uint16_t*>(void_key);
     const DataPackEntry* entry =
         reinterpret_cast<const DataPackEntry*>(void_entry);
     if (key < entry->resource_id) {
       return -1;
@@ skipping 20 matching lines @@
   WRONG_ENCODING,
   INIT_FAILED_FROM_FILE,
 
   LOAD_ERRORS_COUNT,
 };
 
 void LogDataPackError(LoadErrors error) {
   UMA_HISTOGRAM_ENUMERATION("DataPack.Load", error, LOAD_ERRORS_COUNT);
 }
 
+// Prints the given resource id the first time it's loaded if Chrome has been
+// started with --print-resource-ids. This output is then used to generate a
+// more optimal resource renumbering to improve startup speed. See
+// tools/gritsettings/README.md for more info.
+void MaybePrintResourceId(uint16_t resource_id) {
+  // This code is run in other binaries than Chrome which do not initialize the
+  // CommandLine object. Early return in those cases.
+  if (!base::CommandLine::InitializedForCurrentProcess())
+    return;
+
+  // Note: This switch isn't in ui/base/ui_base_switches.h because ui/base
+  // depends on ui/base/resource and thus it would cause a circular dependency.
+  static bool print_resource_ids =
+      base::CommandLine::ForCurrentProcess()->HasSwitch("print-resource-ids");
+  if (!print_resource_ids)
+    return;
+
+  // Note: This is leaked intentionally. However, it's only allocated if the
+  // above command line is specified, so it shouldn't affect regular users.
+  static std::set<uint16_t>* resource_ids_logged = new std::set<uint16_t>();
+  if (!base::ContainsKey(*resource_ids_logged, resource_id)) {

[Nico, 2017/02/17 21:45:58]

is it guaranteed that we only load resources from a single thread?

[Alexei Svitkine (slow), 2017/02/17 22:30:43]

Good point. I had originally assumed yes, but looking at the header, there is no
such guarantee provided and looking at the implementation, all the functions are
const and just read the data - so it should in theory be useable from multiple
threads after initial construction.

So given the above, I've now added a lock to this function to safeguard against
potential multi-thread access.

+    printf("Resource=%d\n", resource_id);
+    resource_ids_logged->insert(resource_id);
+  }
+}
+
 }  // namespace
 
 namespace ui {
 
 // Abstraction of a data source (memory mapped file or in-memory buffer).
 class DataPack::DataSource {
  public:
   virtual ~DataSource() {}
 
   virtual size_t GetLength() const = 0;
@@ skipping 173 matching lines @@
   // http://crbug.com/371301.
   if (next_entry->file_offset > data_source_->GetLength()) {
     size_t entry_index = target - reinterpret_cast<const DataPackEntry*>(
                                       data_source_->GetData() + kHeaderLength);
     LOG(ERROR) << "Entry #" << entry_index << " in data pack points off end "
                << "of file. This should have been caught when loading. Was the "
                << "file modified?";
     return false;
   }
 
+  MaybePrintResourceId(resource_id);
   size_t length = next_entry->file_offset - target->file_offset;
   data->set(reinterpret_cast<const char*>(data_source_->GetData() +
                                           target->file_offset),
             length);
   return true;
 }
 
 base::RefCountedStaticMemory* DataPack::GetStaticMemory(
     uint16_t resource_id) const {
   base::StringPiece piece;
@@ skipping 115 matching lines @@
       return false;
     }
   }
 
   base::CloseFile(file);
 
   return true;
 }
 
 }  // namespace ui