Moving Windows-only files: remoting/host -> remoting/host/win.

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/elevated_controller_win.h"
+#include "remoting/host/win/elevated_controller.h"
 
 #include <sddl.h>
 
 #include "base/file_util.h"
 #include "base/file_version_info.h"
 #include "base/logging.h"
 #include "base/json/json_reader.h"
 #include "base/json/json_writer.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/path_service.h"
 #include "base/process_util.h"
 #include "base/utf_string_conversions.h"
 #include "base/values.h"
 #include "base/win/scoped_handle.h"
 #include "remoting/host/branding.h"
-#include "remoting/host/elevated_controller_resource.h"
 #include "remoting/host/usage_stats_consent.h"
 #include "remoting/host/verify_config_window_win.h"
+#include "remoting/host/win/elevated_controller_resource.h"
 
 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.
@@ skipping 254 matching lines @@
     return hr;
   }
 
   return S_OK;
 }
 
 } // namespace
 
 namespace remoting {
 
-ElevatedControllerWin::ElevatedControllerWin() : owner_window_(NULL) {
+ElevatedController::ElevatedController() : owner_window_(NULL) {
 }
 
-HRESULT ElevatedControllerWin::FinalConstruct() {
+HRESULT ElevatedController::FinalConstruct() {
   return S_OK;
 }
 
-void ElevatedControllerWin::FinalRelease() {
+void ElevatedController::FinalRelease() {
 }
 
-STDMETHODIMP ElevatedControllerWin::GetConfig(BSTR* config_out) {
+STDMETHODIMP ElevatedController::GetConfig(BSTR* config_out) {
   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.
   std::string file_content;
   base::JSONWriter::Write(config.get(), &file_content);
 
   *config_out = ::SysAllocString(UTF8ToUTF16(file_content).c_str());
   if (config_out == NULL) {
     return E_OUTOFMEMORY;
   }
 
   return S_OK;
 }
 
-STDMETHODIMP ElevatedControllerWin::GetVersion(BSTR* version_out) {
+STDMETHODIMP ElevatedController::GetVersion(BSTR* version_out) {
   // Report the product version number of the daemon controller binary as
   // the host version.
   HMODULE binary = base::GetModuleFromAddress(
       reinterpret_cast<void*>(&ReadConfig));
   scoped_ptr<FileVersionInfo> version_info(
       FileVersionInfo::CreateFileVersionInfoForModule(binary));
 
   string16 version;
   if (version_info.get()) {
     version = version_info->product_version();
   }
 
   *version_out = ::SysAllocString(version.c_str());
   if (version_out == NULL) {
     return E_OUTOFMEMORY;
   }
 
   return S_OK;
 }
 
-STDMETHODIMP ElevatedControllerWin::SetConfig(BSTR config) {
+STDMETHODIMP ElevatedController::SetConfig(BSTR config) {
   // Determine the config directory path and create it if necessary.
   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_);
 }
 
-STDMETHODIMP ElevatedControllerWin::SetOwnerWindow(LONG_PTR window_handle) {
+STDMETHODIMP ElevatedController::SetOwnerWindow(LONG_PTR window_handle) {
   owner_window_ = reinterpret_cast<HWND>(window_handle);
   return S_OK;
 }
 
-STDMETHODIMP ElevatedControllerWin::StartDaemon() {
+STDMETHODIMP ElevatedController::StartDaemon() {
   ScopedScHandle service;
   HRESULT hr = OpenService(&service);
   if (FAILED(hr)) {
     return hr;
   }
 
   // Change the service start type to 'auto'.
   if (!::ChangeServiceConfigW(service,
                               SERVICE_NO_CHANGE,
                               SERVICE_AUTO_START,
@@ skipping 19 matching lines @@
       LOG_GETLASTERROR(ERROR)
           << "Failed to start the '" << kWindowsServiceName << "'service";
 
       return HRESULT_FROM_WIN32(error);
     }
   }
 
   return S_OK;
 }
 
-STDMETHODIMP ElevatedControllerWin::StopDaemon() {
+STDMETHODIMP ElevatedController::StopDaemon() {
   ScopedScHandle service;
   HRESULT hr = OpenService(&service);
   if (FAILED(hr)) {
     return hr;
   }
 
   // Change the service start type to 'manual'.
   if (!::ChangeServiceConfigW(service,
                               SERVICE_NO_CHANGE,
                               SERVICE_DEMAND_START,
@@ skipping 19 matching lines @@
     if (error != ERROR_SERVICE_NOT_ACTIVE) {
       LOG_GETLASTERROR(ERROR)
           << "Failed to stop the '" << kWindowsServiceName << "'service";
       return HRESULT_FROM_WIN32(error);
     }
   }
 
   return S_OK;
 }
 
-STDMETHODIMP ElevatedControllerWin::UpdateConfig(BSTR config) {
+STDMETHODIMP ElevatedController::UpdateConfig(BSTR config) {
   // Parse the config.
   std::string config_str = UTF16ToUTF8(
     string16(static_cast<char16*>(config), ::SysStringLen(config)));
   scoped_ptr<base::Value> config_value(base::JSONReader::Read(config_str));
   if (!config_value.get()) {
     return E_FAIL;
   }
   base::DictionaryValue* config_dict = NULL;
   if (!config_value->GetAsDictionary(&config_dict)) {
     return E_FAIL;
@@ skipping 13 matching lines @@
   }
   // 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);
   return WriteConfig(config_updated_str.c_str(), config_updated_str.size(),
                      owner_window_);
 }
 
-STDMETHODIMP ElevatedControllerWin::GetUsageStatsConsent(BOOL* allowed,
+STDMETHODIMP ElevatedController::GetUsageStatsConsent(BOOL* allowed,
                                                          BOOL* set_by_policy) {
   bool local_allowed;
   bool local_set_by_policy;
   if (remoting::GetUsageStatsConsent(&local_allowed, &local_set_by_policy)) {
     *allowed = local_allowed;
     *set_by_policy = local_set_by_policy;
     return S_OK;
   } else {
     return E_FAIL;
   }
 }
 
-STDMETHODIMP ElevatedControllerWin::SetUsageStatsConsent(BOOL allowed) {
+STDMETHODIMP ElevatedController::SetUsageStatsConsent(BOOL allowed) {
   if (remoting::SetUsageStatsConsent(!!allowed)) {
     return S_OK;
   } else {
     return E_FAIL;
   }
 }
 
-HRESULT ElevatedControllerWin::OpenService(ScopedScHandle* service_out) {
+HRESULT ElevatedController::OpenService(ScopedScHandle* service_out) {
   DWORD error;
 
   ScopedScHandle scmanager(
       ::OpenSCManagerW(NULL, SERVICES_ACTIVE_DATABASE,
                        SC_MANAGER_CONNECT | SC_MANAGER_ENUMERATE_SERVICE));
   if (!scmanager.IsValid()) {
     error = GetLastError();
     LOG_GETLASTERROR(ERROR)
         << "Failed to connect to the service control manager";
 
@@ skipping 10 matching lines @@
         << "Failed to open to the '" << kWindowsServiceName << "' service";
 
     return HRESULT_FROM_WIN32(error);
   }
 
   service_out->Set(service.Take());
   return S_OK;
 }
 
 } // namespace remoting