Fix 15 coverity complaints....

net/tools/dump_cache/dump_files.cc

 // Copyright (c) 2008 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.
 
 // Performs basic inspection of the disk cache files with minimal disruption
 // to the actual files (they still may change if an error is detected on the
 // files).
 
 #include <stdio.h>
 #include <string>
 
 #include "base/file_util.h"
 #include "base/message_loop.h"
 #include "net/base/file_stream.h"
 #include "net/disk_cache/block_files.h"
 #include "net/disk_cache/disk_format.h"
 #include "net/disk_cache/mapped_file.h"
 #include "net/disk_cache/storage_block.h"
 
 namespace {
 
 const wchar_t kIndexName[] = L"index";
 const wchar_t kDataPrefix[] = L"data_";
 
 // Reads the |header_size| bytes from the beginning of file |name|.
-bool ReadHeader(const std::wstring name, char* header, int header_size) {
+bool ReadHeader(const std::wstring& name, char* header, int header_size) {
   net::FileStream file;
   file.Open(FilePath::FromWStringHack(name),
       base::PLATFORM_FILE_OPEN | base::PLATFORM_FILE_READ);
   if (!file.IsOpen()) {
     printf("Unable to open file %ls\n", name.c_str());
     return false;
   }
 
   int read = file.Read(header, header_size, NULL);
   if (read != header_size) {
     printf("Unable to read file %ls\n", name.c_str());
     return false;
   }
   return true;
 }
 
-int GetMajorVersionFromFile(const std::wstring name) {
+int GetMajorVersionFromFile(const std::wstring& name) {
   disk_cache::IndexHeader header;
   if (!ReadHeader(name, reinterpret_cast<char*>(&header), sizeof(header)))
     return 0;
 
   return header.version >> 16;
 }
 
 // Dumps the contents of the Index-file header.
-void DumpIndexHeader(const std::wstring name) {
+void DumpIndexHeader(const std::wstring& name) {
   disk_cache::IndexHeader header;
   if (!ReadHeader(name, reinterpret_cast<char*>(&header), sizeof(header)))
     return;
 
   printf("Index file:\n");
   printf("magic: %x\n", header.magic);
   printf("version: %d.%d\n", header.version >> 16, header.version & 0xffff);
   printf("entries: %d\n", header.num_entries);
   printf("total bytes: %d\n", header.num_bytes);
   printf("last file number: %d\n", header.last_file);
   printf("current id: %d\n", header.this_id);
   printf("table length: %d\n", header.table_len);
   printf("last crash: %d\n", header.crash);
   printf("experiment: %d\n", header.experiment);
   for (int i = 0; i < 5; i++) {
     printf("head %d: 0x%x\n", i, header.lru.heads[i]);
     printf("tail %d: 0x%x\n", i, header.lru.tails[i]);
   }
   printf("transaction: 0x%x\n", header.lru.transaction);
   printf("operation: %d\n", header.lru.operation);
   printf("operation list: %d\n", header.lru.operation_list);
   printf("-------------------------\n\n");
 }
 
 // Dumps the contents of a block-file header.
-void DumpBlockHeader(const std::wstring name) {
+void DumpBlockHeader(const std::wstring& name) {
   disk_cache::BlockFileHeader header;
   if (!ReadHeader(name, reinterpret_cast<char*>(&header), sizeof(header)))
     return;
 
   std::wstring file_name = file_util::GetFilenameFromPath(name);
 
   printf("Block file: %ls\n", file_name.c_str());
   printf("magic: %x\n", header.magic);
   printf("version: %d.%d\n", header.version >> 16, header.version & 0xffff);
   printf("file id: %d\n", header.this_file);
   printf("next file id: %d\n", header.next_file);
   printf("entry size: %d\n", header.entry_size);
   printf("current entries: %d\n", header.num_entries);
   printf("max entries: %d\n", header.max_entries);
   printf("updating: %d\n", header.updating);
   printf("empty sz 1: %d\n", header.empty[0]);
   printf("empty sz 2: %d\n", header.empty[1]);
   printf("empty sz 3: %d\n", header.empty[2]);
   printf("empty sz 4: %d\n", header.empty[3]);
   printf("user 0: 0x%x\n", header.user[0]);
   printf("user 1: 0x%x\n", header.user[1]);
   printf("user 2: 0x%x\n", header.user[2]);
   printf("user 3: 0x%x\n", header.user[3]);
   printf("-------------------------\n\n");
 }
 
 // Simple class that interacts with the set of cache files.
 class CacheDumper {
  public:
-  explicit CacheDumper(const std::wstring path)
+  explicit CacheDumper(const std::wstring& path)
       : path_(path), block_files_(path), index_(NULL) {}
 
   bool Init();
 
   // Reads an entry from disk. Return false when all entries have been already
   // returned.
   bool GetEntry(disk_cache::EntryStore* entry);
 
   // Loads a specific block from the block files.
   bool LoadEntry(disk_cache::CacheAddr addr, disk_cache::EntryStore* entry);
@@ skipping 125 matching lines @@
   printf("entry: 0x%x\n", rankings.contents);
   printf("dirty: %d\n", rankings.dirty);
   printf("pointer: 0x%x\n", rankings.pointer);
   printf("----------\n\n");
 }
 
 }  // namespace.
 
 // -----------------------------------------------------------------------
 
-int GetMajorVersion(const std::wstring input_path) {
+int GetMajorVersion(const std::wstring& input_path) {
   std::wstring index_name(input_path);
   file_util::AppendToPath(&index_name, kIndexName);
 
   int version = GetMajorVersionFromFile(index_name);
   if (!version)
     return 0;
 
   std::wstring data_name(input_path);
   file_util::AppendToPath(&data_name, L"data_0");
   if (version != GetMajorVersionFromFile(data_name))
     return 0;
 
   data_name = input_path;
   file_util::AppendToPath(&data_name, L"data_1");
   if (version != GetMajorVersionFromFile(data_name))
     return 0;
 
   return version;
 }
 
 // Dumps the headers of all files.
-int DumpHeaders(const std::wstring input_path) {
+int DumpHeaders(const std::wstring& input_path) {
   std::wstring index_name(input_path);
   file_util::AppendToPath(&index_name, kIndexName);
   DumpIndexHeader(index_name);
 
   std::wstring pattern(kDataPrefix);
   pattern.append(L"*");
   file_util::FileEnumerator iter(FilePath::FromWStringHack(input_path), false,
                                  file_util::FileEnumerator::FILES, pattern);
   for (std::wstring file = iter.Next().ToWStringHack(); !file.empty();
        file = iter.Next().ToWStringHack()) {
     DumpBlockHeader(file);
   }
 
   return 0;
 }
 
 // Dumps all entries from the cache.
-int DumpContents(const std::wstring input_path) {
+int DumpContents(const std::wstring& input_path) {
   DumpHeaders(input_path);
 
   // We need a message loop, although we really don't run any task.
   MessageLoop loop(MessageLoop::TYPE_IO);
   CacheDumper dumper(input_path);
   if (!dumper.Init())
     return -1;
 
   disk_cache::EntryStore entry;
   while (dumper.GetEntry(&entry)) {
     DumpEntry(entry);
     disk_cache::RankingsNode rankings;
     if (dumper.LoadRankings(entry.rankings_node, &rankings))
       DumpRankings(rankings);
   }
 
   printf("Done.\n");
 
   return 0;
 }