Move networking_private to src/extensions

extensions/browser/api/networking_private/networking_private_chromeos.cc

 // Copyright 2014 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/extensions/api/networking_private/networking_private_chromeos.h"
+#include "extensions/browser/api/networking_private/networking_private_chromeos.h"
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/callback.h"
-#include "chrome/browser/chromeos/profiles/profile_helper.h"
-#include "chrome/browser/extensions/api/networking_private/networking_private_api.h"
-#include "chrome/common/extensions/api/networking_private.h"
 #include "chromeos/dbus/dbus_thread_manager.h"
 #include "chromeos/dbus/shill_manager_client.h"
 #include "chromeos/login/login_state.h"
 #include "chromeos/network/managed_network_configuration_handler.h"
 #include "chromeos/network/network_connection_handler.h"
 #include "chromeos/network/network_device_handler.h"
 #include "chromeos/network/network_event_log.h"
 #include "chromeos/network/network_state.h"
 #include "chromeos/network/network_state_handler.h"
 #include "chromeos/network/network_util.h"
 #include "chromeos/network/onc/onc_signature.h"
 #include "chromeos/network/onc/onc_translator.h"
 #include "chromeos/network/onc/onc_utils.h"
 #include "chromeos/network/portal_detector/network_portal_detector.h"
 #include "components/onc/onc_constants.h"
 #include "content/public/browser/browser_context.h"
+#include "extensions/browser/api/networking_private/networking_private_api.h"
+#include "extensions/browser/extensions_browser_client.h"
+#include "extensions/common/api/networking_private.h"
 
 using chromeos::NetworkHandler;
 using chromeos::NetworkTypePattern;
 using chromeos::ShillManagerClient;
 using extensions::NetworkingPrivateDelegate;
 
 namespace {
 
 chromeos::NetworkStateHandler* GetStateHandler() {
   return NetworkHandler::Get()->network_state_handler();
@@ skipping 12 matching lines @@
     *error = extensions::networking_private::kErrorInvalidNetworkGuid;
     return false;
   }
   *service_path = network->path();
   return true;
 }
 
 bool GetUserIdHash(content::BrowserContext* browser_context,
                    std::string* user_hash,
                    std::string* error) {
-  std::string profile_user_hash =
-      chromeos::ProfileHelper::GetUserIdHashFromProfile(
-          static_cast<Profile*>(browser_context));
+  std::string context_user_hash =
+      extensions::ExtensionsBrowserClient::Get()->GetUserIdHashFromContext(
+          browser_context);
 
   // Currently Chrome OS only configures networks for the primary user.
   // Configuration attempts from other browser contexts should fail.
-  // TODO(stevenjb): use an ExtensionsBrowserClient method to access
-  // ProfileHelper when moving this to src/extensions.
-  if (profile_user_hash != chromeos::LoginState::Get()->primary_user_hash()) {
+  if (context_user_hash != chromeos::LoginState::Get()->primary_user_hash()) {
     // Disallow class requiring a user id hash from a non-primary user context
     // to avoid complexities with the policy code.
     LOG(ERROR) << "networkingPrivate API call from non primary user: "
-               << profile_user_hash;
+               << context_user_hash;
     *error = "Error.NonPrimaryUser";
     return false;
   }
-  *user_hash = profile_user_hash;
+  *user_hash = context_user_hash;
   return true;
 }
 
 void NetworkHandlerDictionaryCallback(
     const NetworkingPrivateDelegate::DictionaryCallback& callback,
     const std::string& service_path,
     const base::DictionaryValue& dictionary) {
   scoped_ptr<base::DictionaryValue> dictionary_copy(dictionary.DeepCopy());
   callback.Run(dictionary_copy.Pass());
 }
@@ skipping 11 matching lines @@
 
 namespace extensions {
 
 NetworkingPrivateChromeOS::NetworkingPrivateChromeOS(
     content::BrowserContext* browser_context,
     scoped_ptr<VerifyDelegate> verify_delegate)
     : NetworkingPrivateDelegate(verify_delegate.Pass()),
       browser_context_(browser_context) {
 }
 
-NetworkingPrivateChromeOS::~NetworkingPrivateChromeOS() {}
+NetworkingPrivateChromeOS::~NetworkingPrivateChromeOS() {
+}
 
 void NetworkingPrivateChromeOS::GetProperties(
     const std::string& guid,
     const DictionaryCallback& success_callback,
     const FailureCallback& failure_callback) {
   std::string service_path, error;
   if (!GetServicePathFromGuid(guid, &service_path, &error)) {
     failure_callback.Run(error);
     return;
   }
@@ skipping 14 matching lines @@
     return;
   }
 
   std::string user_id_hash;
   if (!GetUserIdHash(browser_context_, &user_id_hash, &error)) {
     failure_callback.Run(error);
     return;
   }
 
   GetManagedConfigurationHandler()->GetManagedProperties(
-      user_id_hash,
-      service_path,
+      user_id_hash, service_path,
       base::Bind(&NetworkHandlerDictionaryCallback, success_callback),
       base::Bind(&NetworkHandlerFailureCallback, failure_callback));
 }
 
 void NetworkingPrivateChromeOS::GetState(
     const std::string& guid,
     const DictionaryCallback& success_callback,
     const FailureCallback& failure_callback) {
   std::string service_path, error;
   if (!GetServicePathFromGuid(guid, &service_path, &error)) {
@@ skipping 20 matching lines @@
     scoped_ptr<base::DictionaryValue> properties,
     const VoidCallback& success_callback,
     const FailureCallback& failure_callback) {
   std::string service_path, error;
   if (!GetServicePathFromGuid(guid, &service_path, &error)) {
     failure_callback.Run(error);
     return;
   }
 
   GetManagedConfigurationHandler()->SetProperties(
-      service_path,
-      *properties,
-      success_callback,
+      service_path, *properties, success_callback,
       base::Bind(&NetworkHandlerFailureCallback, failure_callback));
 }
 
 void NetworkingPrivateChromeOS::CreateNetwork(
     bool shared,
     scoped_ptr<base::DictionaryValue> properties,
     const StringCallback& success_callback,
     const FailureCallback& failure_callback) {
   std::string user_id_hash, error;
   // Do not allow configuring a non-shared network from a non-primary user.
   if (!shared && !GetUserIdHash(browser_context_, &user_id_hash, &error)) {
     failure_callback.Run(error);
     return;
   }
 
   GetManagedConfigurationHandler()->CreateConfiguration(
-      user_id_hash,
-      *properties,
-      success_callback,
+      user_id_hash, *properties, success_callback,
       base::Bind(&NetworkHandlerFailureCallback, failure_callback));
 }
 
 void NetworkingPrivateChromeOS::GetNetworks(
     const std::string& network_type,
     bool configured_only,
     bool visible_only,
     int limit,
     const NetworkListCallback& success_callback,
     const FailureCallback& failure_callback) {
@@ skipping 10 matching lines @@
     const VoidCallback& success_callback,
     const FailureCallback& failure_callback) {
   std::string service_path, error;
   if (!GetServicePathFromGuid(guid, &service_path, &error)) {
     failure_callback.Run(error);
     return;
   }
 
   const bool check_error_state = false;
   NetworkHandler::Get()->network_connection_handler()->ConnectToNetwork(
-      service_path,
-      success_callback,
+      service_path, success_callback,
       base::Bind(&NetworkHandlerFailureCallback, failure_callback),
       check_error_state);
 }
 
 void NetworkingPrivateChromeOS::StartDisconnect(
     const std::string& guid,
     const VoidCallback& success_callback,
     const FailureCallback& failure_callback) {
   std::string service_path, error;
   if (!GetServicePathFromGuid(guid, &service_path, &error)) {
     failure_callback.Run(error);
     return;
   }
 
   NetworkHandler::Get()->network_connection_handler()->DisconnectNetwork(
-      service_path,
-      success_callback,
+      service_path, success_callback,
       base::Bind(&NetworkHandlerFailureCallback, failure_callback));
 }
 
 void NetworkingPrivateChromeOS::SetWifiTDLSEnabledState(
     const std::string& ip_or_mac_address,
     bool enabled,
     const StringCallback& success_callback,
     const FailureCallback& failure_callback) {
   NetworkHandler::Get()->network_device_handler()->SetWifiTDLSEnabled(
-      ip_or_mac_address,
-      enabled,
-      success_callback,
+      ip_or_mac_address, enabled, success_callback,
       base::Bind(&NetworkHandlerFailureCallback, failure_callback));
 }
 
 void NetworkingPrivateChromeOS::GetWifiTDLSStatus(
     const std::string& ip_or_mac_address,
     const StringCallback& success_callback,
     const FailureCallback& failure_callback) {
   NetworkHandler::Get()->network_device_handler()->GetWifiTDLSStatus(
-      ip_or_mac_address,
-      success_callback,
+      ip_or_mac_address, success_callback,
       base::Bind(&NetworkHandlerFailureCallback, failure_callback));
 }
 
 void NetworkingPrivateChromeOS::GetCaptivePortalStatus(
     const std::string& guid,
     const StringCallback& success_callback,
     const FailureCallback& failure_callback) {
   if (!chromeos::NetworkPortalDetector::IsInitialized()) {
     failure_callback.Run(networking_private::kErrorNotReady);
     return;
@@ skipping 42 matching lines @@
 
   return true;
 }
 
 bool NetworkingPrivateChromeOS::RequestScan() {
   GetStateHandler()->RequestScan();
   return true;
 }
 
 }  // namespace extensions