Add unit-test for SharedSampler handling of zero-thread processes.

chrome/browser/task_manager/sampling/shared_sampler_win_unittest.cc

 // Copyright 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 "chrome/browser/task_manager/sampling/shared_sampler.h"
 
 #include <windows.h>
 
 #include <memory>
 
 #include "base/callback.h"
 #include "base/macros.h"
 #include "base/memory/ref_counted.h"
+#include "base/path_service.h"
 #include "base/run_loop.h"
 #include "base/sequenced_task_runner.h"
 #include "base/time/time.h"
+#include "chrome/browser/task_manager/sampling/shared_sampler_win_defines.h"
 #include "chrome/browser/task_manager/task_manager_observer.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/test/test_browser_thread_bundle.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace task_manager {
 
 // This test class drives SharedSampler in a way similar to the real
 // implementation in TaskManagerImpl and TaskGroup.
 class SharedSamplerTest : public testing::Test {
  public:
   SharedSamplerTest()
-    : blocking_pool_runner_(GetBlockingPoolRunner()),
-      shared_sampler_(new SharedSampler(blocking_pool_runner_)) {
+      : blocking_pool_runner_(GetBlockingPoolRunner()),
+        shared_sampler_(new SharedSampler(blocking_pool_runner_)) {
     shared_sampler_->RegisterCallbacks(
         base::GetCurrentProcId(),
         base::Bind(&SharedSamplerTest::OnIdleWakeupsRefreshDone,
                    base::Unretained(this)),
         base::Bind(&SharedSamplerTest::OnPhysicalMemoryUsageRefreshDone,
                    base::Unretained(this)),
         base::Bind(&SharedSamplerTest::OnStartTimeRefreshDone,
                    base::Unretained(this)),
         base::Bind(&SharedSamplerTest::OnCpuTimeRefreshDone,
                    base::Unretained(this)));
-   }
+  }
 
   ~SharedSamplerTest() override {}
 
  protected:
   int64_t physical_bytes() const { return physical_bytes_; }
 
   base::Time start_time() const { return start_time_; }
 
   base::TimeDelta cpu_time() const { return cpu_time_; }
 
@@ skipping 142 matching lines @@
 // Verifies that multiple refresh types can be refreshed at the same time.
 TEST_F(SharedSamplerTest, MultipleRefreshTypes) {
   StartRefresh(REFRESH_TYPE_IDLE_WAKEUPS | REFRESH_TYPE_PHYSICAL_MEMORY |
                REFRESH_TYPE_START_TIME | REFRESH_TYPE_CPU_TIME);
   WaitUntilRefreshDone();
   EXPECT_EQ(REFRESH_TYPE_IDLE_WAKEUPS | REFRESH_TYPE_PHYSICAL_MEMORY |
                 REFRESH_TYPE_START_TIME | REFRESH_TYPE_CPU_TIME,
             finished_refresh_type());
 }
 
+static int ReturnZeroThreadProcessInformation(unsigned char* buffer,
+                                              int buffer_size) {
+  // Calculate the number of bytes required for the structure, and ImageName.
+  base::FilePath current_exe;
+  CHECK(PathService::Get(base::FILE_EXE, &current_exe));
+  base::string16 image_name = current_exe.BaseName().value();
+
+  const int kImageNameBytes = image_name.length() * sizeof(base::char16);
+  const int kRequiredBytes = sizeof(SYSTEM_PROCESS_INFORMATION) +
+                             kImageNameBytes + sizeof(base::char16);
+  if (kRequiredBytes > buffer_size)
+    return kRequiredBytes;
+
+  // Create a zero'd structure, so that fields such as thread count will be zero
+  // by default.
+  // Set process handle and image name, so the SharedSampler will match us.
+  memset(buffer, 0, kRequiredBytes);
+  SYSTEM_PROCESS_INFORMATION* process_info =
+      reinterpret_cast<SYSTEM_PROCESS_INFORMATION*>(buffer);
+  process_info->ProcessId = reinterpret_cast<HANDLE>(base::GetCurrentProcId());
+  process_info->ImageName.Length = process_info->ImageName.MaximumLength =
+      kImageNameBytes;
+  process_info->ImageName.Buffer = reinterpret_cast<LPWSTR>(process_info + 1);
+  process_info->NumberOfThreads = 0u;
+  process_info->WorkingSetPrivateSize = 1024ull;
+  buffer += sizeof(SYSTEM_PROCESS_INFORMATION);
+
+  // Copy the image name into place. The earlier memset() provides null
+  // termination.
+  memcpy(buffer, image_name.data(), kImageNameBytes);
+
+  return kRequiredBytes;
+}
+
+// Verifies that the SharedSampler copes with zero-thread processes.
+TEST_F(SharedSamplerTest, ZeroThreadProcess) {
+  SharedSampler::SetQuerySystemInformationForTest(
+      ReturnZeroThreadProcessInformation);
+
+  StartRefresh(REFRESH_TYPE_IDLE_WAKEUPS | REFRESH_TYPE_PHYSICAL_MEMORY |
+               REFRESH_TYPE_START_TIME | REFRESH_TYPE_CPU_TIME);
+  WaitUntilRefreshDone();
+  EXPECT_EQ(REFRESH_TYPE_IDLE_WAKEUPS | REFRESH_TYPE_PHYSICAL_MEMORY |
+                REFRESH_TYPE_START_TIME | REFRESH_TYPE_CPU_TIME,
+            finished_refresh_type());
+
+  EXPECT_EQ(1024ll, physical_bytes());
+
+  SharedSampler::SetQuerySystemInformationForTest(nullptr);
+}
+
 }  // namespace task_manager