Convert Media Galleries to use base::File

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 base::PlatformFileError;
 using content::BrowserThread;
 using std::map;
 using std::set;
 using std::string;
 using std::vector;
 
 namespace {
 
 typedef int32 Trigram;
 typedef char TrigramChar;
@@ skipping 298 matching lines @@
   }
   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));
 }
 
 void DevToolsFileSystemIndexer::FileSystemIndexingJob::StartFileIndexing(
-    PlatformFileError error,
+    base::File::Error error,
     PassPlatformFile pass_file,
     bool) {
-  if (error != base::PLATFORM_FILE_OK) {
+  if (error != base::File::FILE_OK) {
     current_file_ = base::kInvalidPlatformFileValue;
     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));
 }
 
 void DevToolsFileSystemIndexer::FileSystemIndexingJob::OnRead(
-    PlatformFileError error,
+    base::File::Error error,
     const char* data,
     int bytes_read) {
-  if (error != base::PLATFORM_FILE_OK) {
+  if (error != base::File::FILE_OK) {
     FinishFileIndexing(false);
     return;
   }
 
   if (!bytes_read || bytes_read < 3) {
     FinishFileIndexing(true);
     return;
   }
 
   size_t size = static_cast<size_t>(bytes_read);
@@ skipping 36 matching lines @@
 void DevToolsFileSystemIndexer::FileSystemIndexingJob::CloseFile() {
   if (current_file_ != base::kInvalidPlatformFileValue) {
     FileUtilProxy::Close(
         BrowserThread::GetMessageLoopProxyForThread(BrowserThread::FILE).get(),
         current_file_,
         Bind(&FileSystemIndexingJob::CloseCallback, this));
   }
 }
 
 void DevToolsFileSystemIndexer::FileSystemIndexingJob::CloseCallback(
-    PlatformFileError error) {}
+    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_;
     if (delta.InMilliseconds() < kMinTimeoutBetweenWorkedNitification)
       should_send_worked_nitification = false;
   }
   ++files_indexed_;
@@ skipping 54 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));
 }