[win] Enable ModuleDatabase behind a flag.

chrome/browser/conflicts/module_event_sink_impl_win.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/conflicts/module_event_sink_impl_win.h"
 
 #include <windows.h>
 #include <psapi.h>
 
 #include <utility>
 
 #include "base/bind.h"
 #include "base/callback.h"
 #include "base/files/file_path.h"
 #include "base/macros.h"
 #include "base/memory/ptr_util.h"
 #include "base/strings/string_piece.h"
 #include "chrome/browser/conflicts/module_database_win.h"
 #include "chrome/common/conflicts/module_watcher_win.h"
 #include "content/public/browser/browser_thread.h"
 #include "mojo/public/cpp/bindings/strong_binding.h"
 
 namespace {
 
-// Gets the process creation time associated with the given process.
-bool GetProcessCreationTime(base::ProcessHandle process,
-                            uint64_t* creation_time) {
-  FILETIME creation_ft = {};
-  FILETIME exit_ft = {};
-  FILETIME kernel_ft = {};
-  FILETIME user_ft = {};
-  if (!::GetProcessTimes(process, &creation_ft, &exit_ft, &kernel_ft,
-                         &user_ft)) {
-    return false;
-  }
-  *creation_time = (static_cast<uint64_t>(creation_ft.dwHighDateTime) << 32) |
-                   static_cast<uint64_t>(creation_ft.dwLowDateTime);
-  return true;
-}
-
 // Gets the path of the module in the provided remote process. Returns true on
 // success, false otherwise.
 bool GetModulePath(base::ProcessHandle process,
                    HMODULE module,
                    base::FilePath* path) {
   std::vector<wchar_t> temp_path(MAX_PATH);
   size_t length = 0;
   while (true) {
     length = ::GetModuleFileNameEx(process, module, temp_path.data(),
                                    temp_path.size());
@@ skipping 74 matching lines @@
   if (!GetProcessCreationTime(process_, &creation_time_)) {
     in_error_ = true;
     return;
   }
   module_database->OnProcessStarted(process_id_, creation_time_, process_type);
 }
 
 ModuleEventSinkImpl::~ModuleEventSinkImpl() = default;
 
 // static
-void ModuleEventSinkImpl::Create(base::ProcessHandle process,
-                                 content::ProcessType process_type,
-                                 ModuleDatabase* module_database,
-                                 mojom::ModuleEventSinkRequest request) {
+void ModuleEventSinkImpl::Create(
+    const GetProcessHandleCallback& get_process_handle,
+    content::ProcessType process_type,
+    ModuleDatabase* module_database,
+    mojom::ModuleEventSinkRequest request) {
   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
+  base::ProcessHandle process = get_process_handle.Run();

[grt (UTC plus 2), 2017/01/06 09:44:58]

std::move(get_process_handle).Run() to "consume" the callback?

[chrisha, 2017/01/10 21:01:46]

I'm fine with that, but have never seen it. Is this a common pattern?

[grt (UTC plus 2), 2017/01/11 15:07:54]

I found it in
https://chromium.googlesource.com/chromium/src/+/master/docs/callback.md. I had
second thoughts about this comment after I sent it. I think it's for
OnceCallback, which you're not using, so maybe it's not good style.

[chrisha, 2017/01/11 21:14:11]

Acknowledged.

   auto module_event_sink_impl = base::MakeUnique<ModuleEventSinkImpl>(
       process, process_type, module_database);
   base::Closure error_handler = base::Bind(
       &ModuleDatabase::OnProcessEnded, base::Unretained(module_database),
       module_event_sink_impl->process_id_,
       module_event_sink_impl->creation_time_);
   auto binding = mojo::MakeStrongBinding(std::move(module_event_sink_impl),
                                          std::move(request));
   binding->set_connection_error_handler(error_handler);
 }
@@ skipping 12 matching lines @@
   switch (event_type) {
     case mojom::ModuleEventType::MODULE_ALREADY_LOADED:
     case mojom::ModuleEventType::MODULE_LOADED:
       return OnModuleLoad(load_address);
 
     case mojom::ModuleEventType::MODULE_UNLOADED:
       return OnModuleUnload(load_address);
   }
 }
 
+// static
+bool ModuleEventSinkImpl::GetProcessCreationTime(base::ProcessHandle process,
+                                                 uint64_t* creation_time) {
+  FILETIME creation_ft = {};
+  FILETIME exit_ft = {};
+  FILETIME kernel_ft = {};
+  FILETIME user_ft = {};
+  if (!::GetProcessTimes(process, &creation_ft, &exit_ft, &kernel_ft,
+                         &user_ft)) {
+    return false;
+  }
+  *creation_time = (static_cast<uint64_t>(creation_ft.dwHighDateTime) << 32) |
+                   static_cast<uint64_t>(creation_ft.dwLowDateTime);
+  return true;
+}
+
 void ModuleEventSinkImpl::OnModuleLoad(uint64_t load_address) {
   if (in_error_)
     return;
 
   // The |load_address| is a unique key to a module in a remote process. If
   // there is a valid module there then the following queries should all pass.
   // If any of them fail then the load event is silently swallowed. The entire
   // channel is not marked as being in an error mode, as later events may be
   // well formed.
 
@@ skipping 19 matching lines @@
   module_database_->OnModuleLoad(process_id_, creation_time_, module_path,
                                  module_size, module_time_date_stamp,
                                  load_address);
 }
 
 void ModuleEventSinkImpl::OnModuleUnload(uint64_t load_address) {
   // Forward this directly to the module database.
   module_database_->OnModuleUnload(process_id_, creation_time_,
                                    static_cast<uintptr_t>(load_address));
 }