Migrate DevToolsFileSystemIndexer to base::FileProxy

chrome/browser/devtools/devtools_file_system_indexer.cc

 // Copyright 2013 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/devtools/devtools_file_system_indexer.h"
 
 #include <iterator>
 
 #include "base/bind.h"
 #include "base/callback.h"
 #include "base/file_util.h"
 #include "base/files/file_enumerator.h"
 #include "base/files/file_util_proxy.h"
 #include "base/lazy_instance.h"
 #include "base/logging.h"
 #include "base/platform_file.h"
 #include "base/strings/utf_string_conversions.h"
 #include "content/public/browser/browser_thread.h"
 
 using base::Bind;
 using base::Callback;
 using base::FileEnumerator;
 using base::FilePath;
-using base::FileUtilProxy;
 using base::Time;
 using base::TimeDelta;
 using base::TimeTicks;
 using base::PassPlatformFile;
 using base::PlatformFile;
 using content::BrowserThread;
 using std::map;
 using std::set;
 using std::string;
 using std::vector;
@@ skipping 227 matching lines @@
 
 DevToolsFileSystemIndexer::FileSystemIndexingJob::FileSystemIndexingJob(
     const FilePath& file_system_path,
     const TotalWorkCallback& total_work_callback,
     const WorkedCallback& worked_callback,
     const DoneCallback& done_callback)
     : file_system_path_(file_system_path),
       total_work_callback_(total_work_callback),
       worked_callback_(worked_callback),
       done_callback_(done_callback),
+      current_file_(BrowserThread::GetMessageLoopProxyForThread(
+                        BrowserThread::FILE).get()),
       files_indexed_(0),
       stopped_(false) {
   current_trigrams_set_.resize(kTrigramCount);
   current_trigrams_.reserve(kTrigramCount);
 }
 
 DevToolsFileSystemIndexer::FileSystemIndexingJob::~FileSystemIndexingJob() {}
 
 void DevToolsFileSystemIndexer::FileSystemIndexingJob::Start() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
@@ skipping 48 matching lines @@
 void DevToolsFileSystemIndexer::FileSystemIndexingJob::IndexFiles() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
   if (stopped_)
     return;
   if (indexing_it_ == file_path_times_.end()) {
     g_trigram_index.Get().NormalizeVectors();
     BrowserThread::PostTask(BrowserThread::UI, FROM_HERE, done_callback_);
     return;
   }
   FilePath file_path = indexing_it_->first;
-  FileUtilProxy::CreateOrOpen(
-      BrowserThread::GetMessageLoopProxyForThread(BrowserThread::FILE).get(),
-      file_path,
-      base::PLATFORM_FILE_OPEN | base::PLATFORM_FILE_READ,
-      Bind(&FileSystemIndexingJob::StartFileIndexing, this));
+  current_file_.CreateOrOpen(
+        file_path,
+        base::File::FLAG_OPEN | base::File::FLAG_READ,
+        Bind(&FileSystemIndexingJob::StartFileIndexing, this));
 }
 
 void DevToolsFileSystemIndexer::FileSystemIndexingJob::StartFileIndexing(
-    base::File::Error error,
-    PassPlatformFile pass_file,
-    bool) {
-  if (error != base::File::FILE_OK) {
-    current_file_ = base::kInvalidPlatformFileValue;
+    base::File::Error error) {
+  if (!current_file_.IsValid()) {
     FinishFileIndexing(false);
     return;
   }
-  current_file_ = pass_file.ReleaseValue();
   current_file_offset_ = 0;
   current_trigrams_.clear();
   std::fill(current_trigrams_set_.begin(), current_trigrams_set_.end(), false);
   ReadFromFile();
 }
 
 void DevToolsFileSystemIndexer::FileSystemIndexingJob::ReadFromFile() {
   if (stopped_) {
     CloseFile();
     return;
   }
-  FileUtilProxy::Read(
-      BrowserThread::GetMessageLoopProxyForThread(BrowserThread::FILE).get(),
-      current_file_,
-      current_file_offset_,
-      kMaxReadLength,
-      Bind(&FileSystemIndexingJob::OnRead, this));
+  current_file_.Read(current_file_offset_, kMaxReadLength,
+                     Bind(&FileSystemIndexingJob::OnRead, this));
 }
 
 void DevToolsFileSystemIndexer::FileSystemIndexingJob::OnRead(
     base::File::Error error,
     const char* data,
     int bytes_read) {
   if (error != base::File::FILE_OK) {
     FinishFileIndexing(false);
     return;
   }
@@ skipping 34 matching lines @@
     FilePath file_path = indexing_it_->first;
     g_trigram_index.Get().SetTrigramsForFile(
         file_path, current_trigrams_, file_path_times_[file_path]);
   }
   ReportWorked();
   ++indexing_it_;
   IndexFiles();
 }
 
 void DevToolsFileSystemIndexer::FileSystemIndexingJob::CloseFile() {
-  if (current_file_ != base::kInvalidPlatformFileValue) {
-    FileUtilProxy::Close(
-        BrowserThread::GetMessageLoopProxyForThread(BrowserThread::FILE).get(),
-        current_file_,
-        Bind(&FileSystemIndexingJob::CloseCallback, this));
-  }
+  if (current_file_.IsValid())
+    current_file_.Close(Bind(&FileSystemIndexingJob::CloseCallback, this));
 }
 
 void DevToolsFileSystemIndexer::FileSystemIndexingJob::CloseCallback(
     base::File::Error error) {}
 
 void DevToolsFileSystemIndexer::FileSystemIndexingJob::ReportWorked() {
   TimeTicks current_time = TimeTicks::Now();
   bool should_send_worked_nitification = true;
   if (!last_worked_notification_time_.is_null()) {
     TimeDelta delta = current_time - last_worked_notification_time_;
@@ skipping 58 matching lines @@
   vector<FilePath> file_paths = g_trigram_index.Get().Search(query);
   vector<string> result;
   FilePath path = FilePath::FromUTF8Unsafe(file_system_path);
   vector<FilePath>::const_iterator it = file_paths.begin();
   for (; it != file_paths.end(); ++it) {
     if (path.IsParent(*it))
       result.push_back(it->AsUTF8Unsafe());
   }
   BrowserThread::PostTask(BrowserThread::UI, FROM_HERE, Bind(callback, result));
 }