Update Crashpad to 8e37886d418dd042c3c7bfadac99214739ee4d98

third_party/crashpad/crashpad/snapshot/mac/process_reader_test.cc

 // Copyright 2014 The Crashpad Authors. All rights reserved.
 //
 // Licensed under the Apache License, Version 2.0 (the "License");
 // you may not use this file except in compliance with the License.
 // You may obtain a copy of the License at
 //
 //     http://www.apache.org/licenses/LICENSE-2.0
 //
 // Unless required by applicable law or agreed to in writing, software
 // distributed under the License is distributed on an "AS IS" BASIS,
@@ skipping 87 matching lines @@
 #else
     EXPECT_TRUE(process_reader.Is64Bit());
 #endif
 
     EXPECT_EQ(getpid(), process_reader.ParentProcessID());
     EXPECT_EQ(ChildPID(), process_reader.ProcessID());
 
     FileHandle read_handle = ReadPipeHandle();
 
     mach_vm_address_t address;
-    CheckedReadFile(read_handle, &address, sizeof(address));
+    CheckedReadFileExactly(read_handle, &address, sizeof(address));
 
     std::string read_string;
     ASSERT_TRUE(process_reader.Memory()->ReadCString(address, &read_string));
     EXPECT_EQ(kTestMemory, read_string);
   }
 
   void MachMultiprocessChild() override {
     FileHandle write_handle = WritePipeHandle();
 
     mach_vm_address_t address =
@@ skipping 322 matching lines @@
     FileHandle read_handle = ReadPipeHandle();
 
     // Build a map of all expected threads, keyed by each thread’s ID, and with
     // addresses that should lie somewhere within each thread’s stack as values.
     // These IDs and addresses all come from the child process via the pipe.
     ThreadMap thread_map;
     for (size_t thread_index = 0;
          thread_index < thread_count_ + 1;
          ++thread_index) {
       uint64_t thread_id;
-      CheckedReadFile(read_handle, &thread_id, sizeof(thread_id));
+      CheckedReadFileExactly(read_handle, &thread_id, sizeof(thread_id));
 
       TestThreadPool::ThreadExpectation expectation;
-      CheckedReadFile(read_handle,
-                      &expectation.stack_address,
-                      sizeof(expectation.stack_address));
-      CheckedReadFile(read_handle,
-                      &expectation.suspend_count,
-                      sizeof(expectation.suspend_count));
+      CheckedReadFileExactly(read_handle,
+                             &expectation.stack_address,
+                             sizeof(expectation.stack_address));
+      CheckedReadFileExactly(read_handle,
+                             &expectation.suspend_count,
+                             sizeof(expectation.suspend_count));
 
       // There can’t be any duplicate thread IDs.
       EXPECT_EQ(0u, thread_map.count(thread_id));
 
       thread_map[thread_id] = expectation;
     }
 
     const std::vector<ProcessReader::Thread>& threads = process_reader.Threads();
 
     // The child shouldn’t have any threads other than its main thread and the
@@ skipping 253 matching lines @@
     const std::vector<ProcessReader::Module>& modules =
         process_reader.Modules();
 
     // There needs to be at least an entry for the main executable, for a dylib,
     // and for dyld.
     ASSERT_GE(modules.size(), 3u);
 
     FileHandle read_handle = ReadPipeHandle();
 
     uint32_t expect_modules;
-    CheckedReadFile(read_handle, &expect_modules, sizeof(expect_modules));
+    CheckedReadFileExactly(
+        read_handle, &expect_modules, sizeof(expect_modules));
 
     ASSERT_EQ(expect_modules, modules.size());
 
     bool found_cl_kernels = false;
     for (size_t index = 0; index < modules.size(); ++index) {
       SCOPED_TRACE(base::StringPrintf(
           "index %zu, name %s", index, modules[index].name.c_str()));
 
       uint32_t expect_name_length;
-      CheckedReadFile(
+      CheckedReadFileExactly(
           read_handle, &expect_name_length, sizeof(expect_name_length));
 
       // The NUL terminator is not read.
       std::string expect_name(expect_name_length, '\0');
-      CheckedReadFile(read_handle, &expect_name[0], expect_name_length);
+      CheckedReadFileExactly(read_handle, &expect_name[0], expect_name_length);
       EXPECT_EQ(expect_name, modules[index].name);
 
       mach_vm_address_t expect_address;
-      CheckedReadFile(read_handle, &expect_address, sizeof(expect_address));
+      CheckedReadFileExactly(
+          read_handle, &expect_address, sizeof(expect_address));
       ASSERT_TRUE(modules[index].reader);
       EXPECT_EQ(expect_address, modules[index].reader->Address());
 
       if (index == 0 || index == modules.size() - 1) {
         // dyld didn’t load the main executable or itself, so it couldn’t record
         // these timestamps, and they are reported as 0.
         EXPECT_EQ(0, modules[index].timestamp);
       } else if (modules[index].reader->FileType() == MH_BUNDLE &&
                  modules[index].name == "cl_kernels") {
         // cl_kernels doesn’t exist as a file.
@@ skipping 68 matching lines @@
   ScopedOpenCLNoOpKernel ensure_cl_kernels;
   ASSERT_NO_FATAL_FAILURE(ensure_cl_kernels.SetUp());
 
   ProcessReaderModulesChild process_reader_modules_child;
   process_reader_modules_child.Run();
 }
 
 }  // namespace
 }  // namespace test
 }  // namespace crashpad