Performance monitor stats gathering.

base/process_util_win.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 "base/process_util.h"
 
 #include <fcntl.h>
 #include <io.h>
 #include <windows.h>
 #include <userenv.h>
@@ skipping 713 matching lines @@
   PROCESS_MEMORY_COUNTERS_EX pmcx;
   if (private_bytes &&
       GetProcessMemoryInfo(process_,
                            reinterpret_cast<PROCESS_MEMORY_COUNTERS*>(&pmcx),
                            sizeof(pmcx))) {
     *private_bytes = pmcx.PrivateUsage;
   }
 
   if (shared_bytes) {
     WorkingSetKBytes ws_usage;
-    if (!GetWorkingSetKBytes(&ws_usage))
+    if (!GetWorkingSetKBytes(&ws_usage)) {
+      LOG(ERROR) << "GetMemoryBytes return false";

[Devlin, 2012/07/24 15:30:48]

Debug statements generally don't go in CL's.

[mitchellwrosen, 2012/07/27 19:24:51]

I know. It was an accident =P

       return false;
+    }
 
     *shared_bytes = ws_usage.shared * 1024;
   }
 
   return true;
 }
 
 void ProcessMetrics::GetCommittedKBytes(CommittedKBytes* usage) const {
   MEMORY_BASIC_INFORMATION mbi = {0};
   size_t committed_private = 0;
@@ skipping 45 matching lines @@
     DWORD buffer_size = sizeof(PSAPI_WORKING_SET_INFORMATION) +
                         (number_of_entries * sizeof(PSAPI_WORKING_SET_BLOCK));
 
     // if we can't expand the buffer, don't leak the previous
     // contents or pass a NULL pointer to QueryWorkingSet
     PSAPI_WORKING_SET_INFORMATION* new_buffer =
         reinterpret_cast<PSAPI_WORKING_SET_INFORMATION*>(
             realloc(buffer, buffer_size));
     if (!new_buffer) {
       free(buffer);
+      LOG(ERROR) << "GetWorkingSetKBytes returning false 1";
       return false;
     }
     buffer = new_buffer;
 
     // Call the function once to get number of items
     if (QueryWorkingSet(process_, buffer, buffer_size))
       break;  // Success
 
     if (GetLastError() != ERROR_BAD_LENGTH) {
       free(buffer);
+      LOG(ERROR) << "GetWorkingSetKBytes: GetLastError() == " << GetLastError();
+      LOG(ERROR) << "GetWorkingSetKBytes returning false 2";
       return false;
     }
 
     number_of_entries = static_cast<DWORD>(buffer->NumberOfEntries);
 
     // Maybe some entries are being added right now. Increase the buffer to
     // take that into account.
     number_of_entries = static_cast<DWORD>(number_of_entries * 1.25);
 
     if (--retries == 0) {
       free(buffer);  // If we're looping, eventually fail.
+      LOG(ERROR) << "GetWorkingSetKBytes returning false 3";
       return false;
     }
   }
 
   // On windows 2000 the function returns 1 even when the buffer is too small.
   // The number of entries that we are going to parse is the minimum between the
   // size we allocated and the real number of entries.
   number_of_entries =
       std::min(number_of_entries, static_cast<DWORD>(buffer->NumberOfEntries));
   for (unsigned int i = 0; i < number_of_entries; i++) {
@@ skipping 182 matching lines @@
 
   PERFORMANCE_INFORMATION info;
   if (!InternalGetPerformanceInfo(&info, sizeof(info))) {
     DLOG(ERROR) << "Failed to fetch internal performance info.";
     return 0;
   }
   return (info.CommitTotal * system_info.dwPageSize) / 1024;
 }
 
 }  // namespace base