Moving Entry from base::file_util_proxy namespace to within class base::FileU...

base/file_util_proxy.cc

 // Copyright (c) 2010 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/file_util_proxy.h"
 
 #include "base/message_loop_proxy.h"
 
 // TODO(jianli): Move the code from anonymous namespace to base namespace so
 // that all of the base:: prefixes would be unnecessary.
@@ skipping 48 matching lines @@
     // TODO(kinuko): may be better to change the file_util::{Copy,Move}.
     if (!file_util::Delete(dest_file_path, false /* recursive */)) {
       if (!file_util::IsDirectoryEmpty(dest_file_path))
         return base::PLATFORM_FILE_ERROR_NOT_EMPTY;
       return base::PLATFORM_FILE_ERROR_FAILED;
     }
   }
   return base::PLATFORM_FILE_OK;
 }
 
-} // anonymous namespace
+}  // anonymous namespace
 
 class MessageLoopRelay
     : public base::RefCountedThreadSafe<MessageLoopRelay> {
  public:
   MessageLoopRelay()
       : origin_message_loop_proxy_(
             base::MessageLoopProxy::CreateForCurrentThread()),
         error_code_(base::PLATFORM_FILE_OK) {
   }
 
@@ skipping 355 matching lines @@
       set_error_code(base::PLATFORM_FILE_ERROR_NOT_FOUND);
       return;
     }
 
     file_util::FileEnumerator file_enum(
         file_path_, false, static_cast<file_util::FileEnumerator::FILE_TYPE>(
         file_util::FileEnumerator::FILES |
         file_util::FileEnumerator::DIRECTORIES));
     FilePath current;
     while (!(current = file_enum.Next()).empty()) {
-      base::file_util_proxy::Entry entry;
+      base::FileUtilProxy::Entry entry;
       file_util::FileEnumerator::FindInfo info;
       file_enum.GetFindInfo(&info);
       entry.is_directory = file_enum.IsDirectory(info);
       // This will just give the entry's name instead of entire path
       // if we use current.value().
       entry.name = file_util::FileEnumerator::GetFilename(info).value();
       entries_.push_back(entry);
     }
   }
 
   virtual void RunCallback() {
     callback_->Run(error_code(), entries_);
     delete callback_;
   }
 
  private:
   base::FileUtilProxy::ReadDirectoryCallback* callback_;
   FilePath file_path_;
-  std::vector<base::file_util_proxy::Entry> entries_;
+  std::vector<base::FileUtilProxy::Entry> entries_;
 };
 
 class RelayGetFileInfo : public MessageLoopRelay {
  public:
   RelayGetFileInfo(const FilePath& file_path,
                    base::FileUtilProxy::GetFileInfoCallback* callback)
       : callback_(callback),
         file_path_(file_path) {
     DCHECK(callback);
   }
@@ skipping 433 matching lines @@
 
 // static
 bool FileUtilProxy::Flush(
     scoped_refptr<MessageLoopProxy> message_loop_proxy,
     PlatformFile file,
     StatusCallback* callback) {
   return Start(FROM_HERE, message_loop_proxy, new RelayFlush(file, callback));
 }
 
 }  // namespace base