FBTF: Monster ctor patch after changing heuristics in clang plugin.

net/disk_cache/disk_format.h

 // Copyright (c) 2006-2009 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.
 
 // The cache is stored on disk as a collection of block-files, plus an index
 // file plus a collection of external files.
 //
 // Any data blob bigger than kMaxBlockSize (net/addr.h) will be stored on a
 // separate file named f_xxx where x is a hexadecimal number. Shorter data will
 // be stored as a series of blocks on a block-file. In any case, CacheAddr
@@ skipping 62 matching lines @@
   CacheAddr heads[5];
   CacheAddr tails[5];
   CacheAddr transaction;     // In-flight operation target.
   int32     operation;       // Actual in-flight operation.
   int32     operation_list;  // In-flight operation list.
   int32     pad2[7];
 };
 
 // Header for the master index file.
 struct IndexHeader {
+  IndexHeader();
+
   uint32      magic;
   uint32      version;
   int32       num_entries;   // Number of entries currently stored.
   int32       num_bytes;     // Total size of the stored data.
   int32       last_file;     // Last external file created.
   int32       this_id;       // Id for all entries being changed (dirty flag).
   CacheAddr   stats;         // Storage for usage data.
   int32       table_len;     // Actual size of the table (0 == kIndexTablesize).
   int32       crash;         // Signals a previous crash.
   int32       experiment;    // Id of an ongoing test.
   uint64      create_time;   // Creation time for this set of files.
   int32       pad[52];
   LruData     lru;           // Eviction control data.
-  IndexHeader() {
-    memset(this, 0, sizeof(*this));
-    magic = kIndexMagic;
-    version = kCurrentVersion;
-  };
 };
 
 // The structure of the whole index file.
 struct Index {
   IndexHeader header;
   CacheAddr   table[kIndexTablesize];  // Default size. Actual size controlled
                                        // by header.table_len.
 };
 
 // Main structure for an entry on the backing storage. If the key is longer than
@@ skipping 59 matching lines @@
 
 // A block-file is the file used to store information in blocks (could be
 // EntryStore blocks, RankingsNode blocks or user-data blocks).
 // We store entries that can expand for up to 4 consecutive blocks, and keep
 // counters of the number of blocks available for each type of entry. For
 // instance, an entry of 3 blocks is an entry of type 3. We also keep track of
 // where did we find the last entry of that type (to avoid searching the bitmap
 // from the beginning every time).
 // This Structure is the header of a block-file:
 struct BlockFileHeader {
+  BlockFileHeader();
+
   uint32          magic;
   uint32          version;
   int16           this_file;    // Index of this file.
   int16           next_file;    // Next file when this one is full.
   int32           entry_size;   // Size of the blocks of this file.
   int32           num_entries;  // Number of stored entries.
   int32           max_entries;  // Current maximum number of entries.
   int32           empty[4];     // Counters of empty entries for each type.
   int32           hints[4];     // Last used position for each entry type.
   volatile int32  updating;     // Keep track of updates to the header.
   int32           user[5];
   AllocBitmap     allocation_map;
-  BlockFileHeader() {
-    memset(this, 0, sizeof(BlockFileHeader));
-    magic = kBlockMagic;
-    version = kCurrentVersion;
-  };
 };
 
 COMPILE_ASSERT(sizeof(BlockFileHeader) == kBlockHeaderSize, bad_header);
 
 // Sparse data support:
 // We keep a two level hierarchy to enable sparse data for an entry: the first
 // level consists of using separate "child" entries to store ranges of 1 MB,
 // and the second level stores blocks of 1 KB inside each child entry.
 //
 // Whenever we need to access a particular sparse offset, we first locate the
@@ skipping 51 matching lines @@
 };
 
 // The number of blocks stored by a child entry.
 const int kNumSparseBits = 1024;
 COMPILE_ASSERT(sizeof(SparseData) == sizeof(SparseHeader) + kNumSparseBits / 8,
                Invalid_SparseData_bitmap);
 
 }  // namespace disk_cache
 
 #endif  // NET_DISK_CACHE_DISK_FORMAT_H_