[tracing] Smaps provider uses fscanf instead of istream

base/trace_event/process_memory_maps_dump_provider_unittest.cc

 // Copyright 2015 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/trace_event/process_memory_maps_dump_provider.h"
 
-#include <fstream>
-#include <sstream>
+#include <fcntl.h>
 
+#include "base/files/file_util.h"
 #include "base/trace_event/process_memory_dump.h"
 #include "base/trace_event/process_memory_maps.h"
 #include "base/trace_event/trace_event_argument.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace base {
 namespace trace_event {
 
 #if defined(OS_LINUX) || defined(OS_ANDROID)
 namespace {
@@ skipping 77 matching lines @@
     "Private_Clean:         8 kB\n"
     "Private_Dirty:         4 kB\n"
     "Referenced:           40 kB\n"
     "Anonymous:            16 kB\n"
     "AnonHugePages:         0 kB\n"
     "Swap:                  0 kB\n"
     "KernelPageSize:        4 kB\n"
     "MMUPageSize:           4 kB\n"
     "Locked:                0 kB\n"
     "VmFlags: rd wr mr mw me ac sd\n";
+
+void CreateAndSetSmapsFileForTesting(const char* smaps_string, ScopedFD& fd) {
+  FilePath temp_path;
+  FILE* temp_file = CreateAndOpenTemporaryFile(&temp_path);
+  fd.reset(fileno(temp_file));
+  ASSERT_TRUE(fd.is_valid());
+
+  ASSERT_TRUE(
+      base::WriteFileDescriptor(fd.get(), smaps_string, strlen(smaps_string)));
+}
+
 }  // namespace
 
 TEST(ProcessMemoryMapsDumpProviderTest, ParseProcSmaps) {
   const uint32 kProtR = ProcessMemoryMaps::VMRegion::kProtectionFlagsRead;
   const uint32 kProtW = ProcessMemoryMaps::VMRegion::kProtectionFlagsWrite;
   const uint32 kProtX = ProcessMemoryMaps::VMRegion::kProtectionFlagsExec;
   const MemoryDumpArgs dump_args = {MemoryDumpArgs::LevelOfDetail::HIGH};
 
   auto pmmdp = ProcessMemoryMapsDumpProvider::GetInstance();
 
   // Emulate a non-existent /proc/self/smaps.
   ProcessMemoryDump pmd_invalid(nullptr /* session_state */);
-  std::ifstream non_existent_file("/tmp/does-not-exist");
-  ProcessMemoryMapsDumpProvider::proc_smaps_for_testing = &non_existent_file;
-  CHECK_EQ(false, non_existent_file.good());
+  ScopedFD non_existent_fd(open("/tmp/does-not-exist", O_RDONLY));
+  ProcessMemoryMapsDumpProvider::proc_smaps_for_testing = &non_existent_fd;
+  CHECK_EQ(false, non_existent_fd.is_valid());
   pmmdp->OnMemoryDump(dump_args, &pmd_invalid);
   ASSERT_FALSE(pmd_invalid.has_process_mmaps());
 
   // Emulate an empty /proc/self/smaps.
-  std::ifstream empty_file("/dev/null");
+  ScopedFD empty_file(open("/dev/null", O_RDONLY));
+  ASSERT_TRUE(empty_file.is_valid());
   ProcessMemoryMapsDumpProvider::proc_smaps_for_testing = &empty_file;
-  CHECK_EQ(true, empty_file.good());
   pmmdp->OnMemoryDump(dump_args, &pmd_invalid);
   ASSERT_FALSE(pmd_invalid.has_process_mmaps());
 
   // Parse the 1st smaps file.
   ProcessMemoryDump pmd_1(nullptr /* session_state */);
-  std::istringstream test_smaps_1(kTestSmaps1);
-  ProcessMemoryMapsDumpProvider::proc_smaps_for_testing = &test_smaps_1;
+  ScopedFD temp_fd1;
+  CreateAndSetSmapsFileForTesting(kTestSmaps1, temp_fd1);
+  ProcessMemoryMapsDumpProvider::proc_smaps_for_testing = &temp_fd1;
   pmmdp->OnMemoryDump(dump_args, &pmd_1);
   ASSERT_TRUE(pmd_1.has_process_mmaps());
   const auto& regions_1 = pmd_1.process_mmaps()->vm_regions();
   ASSERT_EQ(2UL, regions_1.size());
 
   EXPECT_EQ(0x00400000UL, regions_1[0].start_address);
   EXPECT_EQ(0x004be000UL - 0x00400000UL, regions_1[0].size_in_bytes);
   EXPECT_EQ(kProtR | kProtX, regions_1[0].protection_flags);
   EXPECT_EQ("/file/1", regions_1[0].mapped_file);
   EXPECT_EQ(162 * 1024UL, regions_1[0].byte_stats_proportional_resident);
   EXPECT_EQ(228 * 1024UL, regions_1[0].byte_stats_shared_clean_resident);
   EXPECT_EQ(0UL, regions_1[0].byte_stats_shared_dirty_resident);
   EXPECT_EQ(0UL, regions_1[0].byte_stats_private_clean_resident);
   EXPECT_EQ(68 * 1024UL, regions_1[0].byte_stats_private_dirty_resident);
   EXPECT_EQ(4 * 1024UL, regions_1[0].byte_stats_swapped);
 
   EXPECT_EQ(0xff000000UL, regions_1[1].start_address);
   EXPECT_EQ(0xff800000UL - 0xff000000UL, regions_1[1].size_in_bytes);
   EXPECT_EQ(kProtW, regions_1[1].protection_flags);
   EXPECT_EQ("/file/name with space", regions_1[1].mapped_file);
   EXPECT_EQ(128 * 1024UL, regions_1[1].byte_stats_proportional_resident);
   EXPECT_EQ(120 * 1024UL, regions_1[1].byte_stats_shared_clean_resident);
   EXPECT_EQ(4 * 1024UL, regions_1[1].byte_stats_shared_dirty_resident);
   EXPECT_EQ(60 * 1024UL, regions_1[1].byte_stats_private_clean_resident);
   EXPECT_EQ(8 * 1024UL, regions_1[1].byte_stats_private_dirty_resident);
   EXPECT_EQ(0 * 1024UL, regions_1[1].byte_stats_swapped);
 
   // Parse the 2nd smaps file.
   ProcessMemoryDump pmd_2(nullptr /* session_state */);
-  std::istringstream test_smaps_2(kTestSmaps2);
-  ProcessMemoryMapsDumpProvider::proc_smaps_for_testing = &test_smaps_2;
+  ScopedFD temp_fd2;
+  CreateAndSetSmapsFileForTesting(kTestSmaps2, temp_fd2);
+  ProcessMemoryMapsDumpProvider::proc_smaps_for_testing = &temp_fd2;
   pmmdp->OnMemoryDump(dump_args, &pmd_2);
   ASSERT_TRUE(pmd_2.has_process_mmaps());
   const auto& regions_2 = pmd_2.process_mmaps()->vm_regions();
   ASSERT_EQ(1UL, regions_2.size());
   EXPECT_EQ(0x7fe7ce79c000UL, regions_2[0].start_address);
   EXPECT_EQ(0x7fe7ce7a8000UL - 0x7fe7ce79c000UL, regions_2[0].size_in_bytes);
   EXPECT_EQ(0U, regions_2[0].protection_flags);
   EXPECT_EQ("", regions_2[0].mapped_file);
   EXPECT_EQ(32 * 1024UL, regions_2[0].byte_stats_proportional_resident);
   EXPECT_EQ(16 * 1024UL, regions_2[0].byte_stats_shared_clean_resident);
   EXPECT_EQ(12 * 1024UL, regions_2[0].byte_stats_shared_dirty_resident);
   EXPECT_EQ(8 * 1024UL, regions_2[0].byte_stats_private_clean_resident);
   EXPECT_EQ(4 * 1024UL, regions_2[0].byte_stats_private_dirty_resident);
   EXPECT_EQ(0 * 1024UL, regions_2[0].byte_stats_swapped);
 }
 #endif  // defined(OS_LINUX) || defined(OS_ANDROID)
 
 }  // namespace trace_event
 }  // namespace base