Delete class DirectoryIterator and FileRotatingStream read support.

webrtc/base/filerotatingstream.h

 /*
  *  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 64 matching lines @@
 
   void SetMaxFileSize(size_t size) { max_file_size_ = size; }
 
   size_t GetRotationIndex() const { return rotation_index_; }
 
   void SetRotationIndex(size_t index) { rotation_index_ = index; }
 
   virtual void OnRotation() {}
 
  private:
-  enum Mode { kRead, kWrite };
-
-  FileRotatingStream(const std::string& dir_path,
-                     const std::string& file_prefix,
-                     size_t max_file_size,
-                     size_t num_files,
-                     Mode mode);
-
   bool OpenCurrentFile();
   void CloseCurrentFile();
 
   // Rotates the files by creating a new current file, renaming the
   // existing files, and deleting the oldest one. e.g.
   // file_0 -> file_1
   // file_1 -> file_2
   // file_2 -> delete
   // create new file_0
   void RotateFiles();
 
   // Returns a list of file names in the directory beginning with the prefix.
   std::vector<std::string> GetFilesWithPrefix() const;
   // Private version of GetFilePath.
   std::string GetFilePath(size_t index, size_t num_files) const;
 
   const std::string dir_path_;
   const std::string file_prefix_;
-  const Mode mode_;
 
   // FileStream is used to write to the current file.
   std::unique_ptr<FileStream> file_stream_;
   // Convenience storage for file names so we don't generate them over and over.
   std::vector<std::string> file_names_;
   size_t max_file_size_;
   size_t current_file_index_;
   // The rotation index indicates the index of the file that will be
   // deleted first on rotation. Indices lower than this index will be rotated.
   size_t rotation_index_;
@@ skipping 14 matching lines @@
 //
 // This implementation simply writes to a single file until
 // |max_total_log_size| / 2 bytes are written to it, and subsequently writes to
 // a set of rotating files. We do this by inheriting FileRotatingStream and
 // setting the appropriate internal variables so that we don't delete the last
 // (earliest) file on rotate, and that that file's size is bigger.
 //
 // Open() must be called before using this stream.
 class CallSessionFileRotatingStream : public FileRotatingStream {
  public:
-  // Use this constructor for reading a directory previously written to with
-  // this stream.
-  explicit CallSessionFileRotatingStream(const std::string& dir_path);
   // Use this constructor for writing to a directory. Files in the directory
   // matching what's used by the stream will be deleted. |max_total_log_size|
   // must be at least 4.
   CallSessionFileRotatingStream(const std::string& dir_path,
                                 size_t max_total_log_size);
   ~CallSessionFileRotatingStream() override {}
 
  protected:
   void OnRotation() override;
 
  private:
   static size_t GetRotatingLogSize(size_t max_total_log_size);
   static size_t GetNumRotatingLogFiles(size_t max_total_log_size);
   static const char* kLogPrefix;
   static const size_t kRotatingLogFileDefaultSize;
 
   const size_t max_total_log_size_;
   size_t num_rotations_;
 
   RTC_DISALLOW_COPY_AND_ASSIGN(CallSessionFileRotatingStream);
 };
 
 }  // namespace rtc
 
 #endif  // WEBRTC_BASE_FILEROTATINGSTREAM_H_