Delete Filesystem::IterateDirectory and Filesystem::OpenFile.

webrtc/base/filerotatingstream_unittest.cc

 /*
  *  Copyright 2015 The WebRTC Project Authors. All rights reserved.
  *
  *  Use of this source code is governed by a BSD-style license
  *  that can be found in the LICENSE file in the root of the source
  *  tree. An additional intellectual property rights grant can be found
  *  in the file PATENTS.  All contributing project authors may
  *  be found in the AUTHORS file in the root of the source tree.
  */
 
@@ skipping 78 matching lines @@
               stream->ReadAll(buffer.get(), expected_length, &read, nullptr));
     EXPECT_EQ(0, memcmp(expected_contents, buffer.get(), expected_length));
     EXPECT_EQ(SR_EOS, stream->ReadAll(buffer.get(), 1, nullptr, nullptr));
     EXPECT_EQ(stream_size, read);
   }
 
   void VerifyFileContents(const char* expected_contents,
                           const size_t expected_length,
                           const std::string& file_path) {
     std::unique_ptr<uint8_t[]> buffer(new uint8_t[expected_length]);
-    std::unique_ptr<FileStream> stream(Filesystem::OpenFile(file_path, "r"));
-    EXPECT_TRUE(stream);
-    if (!stream) {
-      return;
-    }
+    FileStream stream;
+    ASSERT_TRUE(stream.Open(file_path, "r", nullptr));
     EXPECT_EQ(rtc::SR_SUCCESS,
-              stream->ReadAll(buffer.get(), expected_length, nullptr, nullptr));
+              stream.ReadAll(buffer.get(), expected_length, nullptr, nullptr));
     EXPECT_EQ(0, memcmp(expected_contents, buffer.get(), expected_length));
     size_t file_size = 0;
-    EXPECT_TRUE(stream->GetSize(&file_size));
+    EXPECT_TRUE(stream.GetSize(&file_size));
     EXPECT_EQ(file_size, expected_length);
   }
 
   std::unique_ptr<FileRotatingStream> stream_;
   std::string dir_path_;
 };
 
 const char* MAYBE_FileRotatingStreamTest::kFilePrefix =
     "FileRotatingStreamTest";
 const size_t MAYBE_FileRotatingStreamTest::kMaxFileSize = 2;
@@ skipping 10 matching lines @@
 }
 
 // Tests that nothing is written to file when data of length zero is written.
 TEST_F(MAYBE_FileRotatingStreamTest, EmptyWrite) {
   Init("FileRotatingStreamTestEmptyWrite", kFilePrefix, kMaxFileSize, 3);
 
   ASSERT_TRUE(stream_->Open());
   WriteAndFlush("a", 0);
 
   std::string logfile_path = stream_->GetFilePath(0);
-  std::unique_ptr<FileStream> stream(Filesystem::OpenFile(logfile_path, "r"));
+  FileStream stream;
+  ASSERT_TRUE(stream.Open(logfile_path, "r", nullptr));
   size_t file_size = 0;
-  EXPECT_TRUE(stream->GetSize(&file_size));
+  EXPECT_TRUE(stream.GetSize(&file_size));
   EXPECT_EQ(0u, file_size);
 }
 
 // Tests that a write operation followed by a read returns the expected data
 // and writes to the expected files.
 TEST_F(MAYBE_FileRotatingStreamTest, WriteAndRead) {
   Init("FileRotatingStreamTestWriteAndRead", kFilePrefix, kMaxFileSize, 3);
 
   ASSERT_TRUE(stream_->Open());
   // The test is set up to create three log files of length 2. Write and check
@@ skipping 186 matching lines @@
   for (size_t i = 0; i < arraysize(expected_vals); ++i) {
     memset(expected_buffer.get(), expected_vals[i], buffer_size);
     EXPECT_EQ(SR_SUCCESS,
               stream_->ReadAll(buffer.get(), buffer_size, nullptr, nullptr));
     EXPECT_EQ(0, memcmp(buffer.get(), expected_buffer.get(), buffer_size));
   }
   EXPECT_EQ(SR_EOS, stream_->ReadAll(buffer.get(), 1, nullptr, nullptr));
 }
 
 }  // namespace rtc