Add FilePath to base namespace.

remoting/host/win/elevated_controller.cc

 // Copyright (c) 2012 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 "remoting/host/win/elevated_controller.h"
 
 #include "base/file_util.h"
 #include "base/file_version_info.h"
 #include "base/logging.h"
 #include "base/json/json_reader.h"
@@ skipping 14 matching lines @@
 
 namespace {
 
 // The maximum size of the configuration file. "1MB ought to be enough" for any
 // reasonable configuration we will ever need. 1MB is low enough to make
 // the probability of out of memory situation fairly low. OOM is still possible
 // and we will crash if it occurs.
 const size_t kMaxConfigFileSize = 1024 * 1024;
 
 // The host configuration file name.
-const FilePath::CharType kConfigFileName[] = FILE_PATH_LITERAL("host.json");
+const base::FilePath::CharType kConfigFileName[] = FILE_PATH_LITERAL("host.json");
 
 // The unprivileged configuration file name.
-const FilePath::CharType kUnprivilegedConfigFileName[] =
+const base::FilePath::CharType kUnprivilegedConfigFileName[] =
     FILE_PATH_LITERAL("host_unprivileged.json");
 
 // The extension for the temporary file.
-const FilePath::CharType kTempFileExtension[] = FILE_PATH_LITERAL("json~");
+const base::FilePath::CharType kTempFileExtension[] = FILE_PATH_LITERAL("json~");
 
 // The host configuration file security descriptor that enables full access to
 // Local System and built-in administrators only.
 const char kConfigFileSecurityDescriptor[] =
     "O:BAG:BAD:(A;;GA;;;SY)(A;;GA;;;BA)";
 
 const char kUnprivilegedConfigFileSecurityDescriptor[] =
     "O:BAG:BAD:(A;;GA;;;SY)(A;;GA;;;BA)(A;;GR;;;AU)";
 
 // Configuration keys.
@@ skipping 32 matching lines @@
   }
 
   hr = CoRevertToSelf();
   CHECK(SUCCEEDED(hr));
 
   return !!result;
 }
 
 // Reads and parses the configuration file up to |kMaxConfigFileSize| in
 // size.
-HRESULT ReadConfig(const FilePath& filename,
+HRESULT ReadConfig(const base::FilePath& filename,
                    scoped_ptr<base::DictionaryValue>* config_out) {
 
   // Read raw data from the configuration file.
   base::win::ScopedHandle file(
       CreateFileW(filename.value().c_str(),
                   GENERIC_READ,
                   FILE_SHARE_READ | FILE_SHARE_WRITE,
                   NULL,
                   OPEN_EXISTING,
                   FILE_FLAG_SEQUENTIAL_SCAN,
@@ skipping 24 matching lines @@
   if (value.get() == NULL || !value->GetAsDictionary(&dictionary)) {
     LOG(ERROR) << "Failed to read '" << filename.value() << "'.";
     return E_FAIL;
   }
 
   value.release();
   config_out->reset(dictionary);
   return S_OK;
 }
 
-FilePath GetTempLocationFor(const FilePath& filename) {
+base::FilePath GetTempLocationFor(const base::FilePath& filename) {
   return filename.ReplaceExtension(kTempFileExtension);
 }
 
 // Writes a config file to a temporary location.
-HRESULT WriteConfigFileToTemp(const FilePath& filename,
+HRESULT WriteConfigFileToTemp(const base::FilePath& filename,
                               const char* security_descriptor,
                               const char* content,
                               size_t length) {
   // Create the security descriptor for the configuration file.
   ScopedSd sd = ConvertSddlToSd(security_descriptor);
   if (!sd) {
     DWORD error = GetLastError();
     LOG_GETLASTERROR(ERROR) <<
         "Failed to create a security descriptor for the configuration file";
     return HRESULT_FROM_WIN32(error);
   }
 
   SECURITY_ATTRIBUTES security_attributes = {0};
   security_attributes.nLength = sizeof(security_attributes);
   security_attributes.lpSecurityDescriptor = sd.get();
   security_attributes.bInheritHandle = FALSE;
 
   // Create a temporary file and write configuration to it.
-  FilePath tempname = GetTempLocationFor(filename);
+  base::FilePath tempname = GetTempLocationFor(filename);
   base::win::ScopedHandle file(
       CreateFileW(tempname.value().c_str(),
                   GENERIC_WRITE,
                   0,
                   &security_attributes,
                   CREATE_ALWAYS,
                   FILE_FLAG_SEQUENTIAL_SCAN,
                   NULL));
 
   if (!file.IsValid()) {
     DWORD error = GetLastError();
     LOG_GETLASTERROR(ERROR)
         << "Failed to create '" << filename.value() << "'";
     return HRESULT_FROM_WIN32(error);
   }
 
   DWORD written;
   if (!WriteFile(file, content, static_cast<DWORD>(length), &written, NULL)) {
     DWORD error = GetLastError();
     LOG_GETLASTERROR(ERROR)
         << "Failed to write to '" << filename.value() << "'";
     return HRESULT_FROM_WIN32(error);
   }
 
   return S_OK;
 }
 
 // Moves a config file from its temporary location to its permanent location.
-HRESULT MoveConfigFileFromTemp(const FilePath& filename) {
+HRESULT MoveConfigFileFromTemp(const base::FilePath& filename) {
   // Now that the configuration is stored successfully replace the actual
   // configuration file.
-  FilePath tempname = GetTempLocationFor(filename);
+  base::FilePath tempname = GetTempLocationFor(filename);
   if (!MoveFileExW(tempname.value().c_str(),
                    filename.value().c_str(),
                    MOVEFILE_REPLACE_EXISTING)) {
       DWORD error = GetLastError();
       LOG_GETLASTERROR(ERROR)
           << "Failed to rename '" << tempname.value() << "' to '"
           << filename.value() << "'";
       return HRESULT_FROM_WIN32(error);
   }
 
@@ skipping 39 matching lines @@
     const char* key = kUnprivilegedConfigKeys[i];
     string16 value;
     if (config_dict->GetString(key, &value)) {
       unprivileged_config_dict.SetString(key, value);
     }
   }
   std::string unprivileged_config_str;
   base::JSONWriter::Write(&unprivileged_config_dict, &unprivileged_config_str);
 
   // Write the full configuration file to a temporary location.
-  FilePath full_config_file_path =
+  base::FilePath full_config_file_path =
       remoting::GetConfigDir().Append(kConfigFileName);
   HRESULT hr = WriteConfigFileToTemp(full_config_file_path,
                                      kConfigFileSecurityDescriptor,
                                      content,
                                      length);
   if (FAILED(hr)) {
     return hr;
   }
 
   // Write the unprivileged configuration file to a temporary location.
-  FilePath unprivileged_config_file_path =
+  base::FilePath unprivileged_config_file_path =
       remoting::GetConfigDir().Append(kUnprivilegedConfigFileName);
   hr = WriteConfigFileToTemp(unprivileged_config_file_path,
                              kUnprivilegedConfigFileSecurityDescriptor,
                              unprivileged_config_str.data(),
                              unprivileged_config_str.size());
   if (FAILED(hr)) {
     return hr;
   }
 
   // Move the full configuration file to its permanent location.
@@ skipping 17 matching lines @@
 }
 
 HRESULT ElevatedController::FinalConstruct() {
   return S_OK;
 }
 
 void ElevatedController::FinalRelease() {
 }
 
 STDMETHODIMP ElevatedController::GetConfig(BSTR* config_out) {
-  FilePath config_dir = remoting::GetConfigDir();
+  base::FilePath config_dir = remoting::GetConfigDir();
 
   // Read the unprivileged part of host configuration.
   scoped_ptr<base::DictionaryValue> config;
   HRESULT hr = ReadConfig(config_dir.Append(kUnprivilegedConfigFileName),
                           &config);
   if (FAILED(hr)) {
     return hr;
   }
 
   // Convert the config back to a string and return it to the caller.
@@ skipping 24 matching lines @@
   *version_out = ::SysAllocString(version.c_str());
   if (version_out == NULL) {
     return E_OUTOFMEMORY;
   }
 
   return S_OK;
 }
 
 STDMETHODIMP ElevatedController::SetConfig(BSTR config) {
   // Determine the config directory path and create it if necessary.
-  FilePath config_dir = remoting::GetConfigDir();
+  base::FilePath config_dir = remoting::GetConfigDir();
   if (!file_util::CreateDirectory(config_dir)) {
     return HRESULT_FROM_WIN32(ERROR_ACCESS_DENIED);
   }
 
   std::string file_content = UTF16ToUTF8(
     string16(static_cast<char16*>(config), ::SysStringLen(config)));
 
   return WriteConfig(file_content.c_str(), file_content.size(), owner_window_);
 }
 
@@ skipping 94 matching lines @@
   if (!config_value->GetAsDictionary(&config_dict)) {
     return E_FAIL;
   }
   // Check for bad keys.
   for (int i = 0; i < arraysize(kReadonlyKeys); ++i) {
     if (config_dict->HasKey(kReadonlyKeys[i])) {
       return HRESULT_FROM_WIN32(ERROR_ACCESS_DENIED);
     }
   }
   // Get the old config.
-  FilePath config_dir = remoting::GetConfigDir();
+  base::FilePath config_dir = remoting::GetConfigDir();
   scoped_ptr<base::DictionaryValue> config_old;
   HRESULT hr = ReadConfig(config_dir.Append(kConfigFileName), &config_old);
   if (FAILED(hr)) {
     return hr;
   }
   // Merge items from the given config into the old config.
   config_old->MergeDictionary(config_dict);
   // Write the updated config.
   std::string config_updated_str;
   base::JSONWriter::Write(config_old.get(), &config_updated_str);
@@ skipping 46 matching lines @@
         << "Failed to open to the '" << kWindowsServiceName << "' service";
 
     return HRESULT_FROM_WIN32(error);
   }
 
   service_out->Set(service.Take());
   return S_OK;
 }
 
 } // namespace remoting