Address codereview comments for http://crrev.com/22295002

chrome/utility/networking_private_handler.cc

 // Copyright (c) 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/utility/networking_private_handler.h"
 
 #include "base/bind.h"
 #include "base/json/json_reader.h"
 #include "base/memory/ref_counted.h"
 #include "base/message_loop/message_loop_proxy.h"
 #include "base/threading/thread.h"
 #include "chrome/common/networking_private_messages.h"
 #include "content/public/utility/utility_thread.h"
 
 using wifi::WiFiService;
 
 namespace chrome {
 
 NetworkingPrivateHandler::NetworkingPrivateHandler()
     : wifi_service_(WiFiService::CreateService()) {
   wifi_service_->SetNetworksChangedObserver(
-      base::Bind(&NetworkingPrivateHandler::OnNetworksChangedEvent,
+      base::Bind(&NetworkingPrivateHandler::WiFiNetworksChangedEvent,
                  base::Unretained(this)));
   wifi_service_->SetNetworkListChangedObserver(
-      base::Bind(&NetworkingPrivateHandler::OnNetworkListChangedEvent,
+      base::Bind(&NetworkingPrivateHandler::WiFiNetworkListChangedEvent,
                  base::Unretained(this)));
 }
 
 NetworkingPrivateHandler::~NetworkingPrivateHandler() {}
 
 bool NetworkingPrivateHandler::OnMessageReceived(const IPC::Message& message) {
   bool handled = true;
   IPC_BEGIN_MESSAGE_MAP(NetworkingPrivateHandler, message)
   IPC_MESSAGE_HANDLER(NetworkingPrivateMsg_UseWiFiServiceMock_ForTest,
                       OnUseWiFiServiceMockForTest)
   IPC_MESSAGE_HANDLER(NetworkingPrivateMsg_GetProperties, OnGetPropertiesStart)
   IPC_MESSAGE_HANDLER(NetworkingPrivateMsg_SetProperties, OnSetPropertiesStart)
   IPC_MESSAGE_HANDLER(NetworkingPrivateMsg_StartConnect, OnStartConnectStart)
   IPC_MESSAGE_HANDLER(NetworkingPrivateMsg_StartDisconnect,
                       OnStartDisconnectStart)
   IPC_MESSAGE_HANDLER(NetworkingPrivateMsg_GetVisibleNetworks,
                       OnGetVisibleNetworks)
   IPC_MESSAGE_HANDLER(NetworkingPrivateMsg_RequestNetworkScan,
                       OnRequestNetworkScan)
   IPC_MESSAGE_UNHANDLED(handled = false)
   IPC_END_MESSAGE_MAP()
   return handled;
 }
 
 void NetworkingPrivateHandler::OnUseWiFiServiceMockForTest(
     const base::DictionaryValue& parameters) {
   wifi_service_.reset(WiFiService::CreateServiceMock());
   wifi_service_->SetNetworksChangedObserver(
-      base::Bind(&NetworkingPrivateHandler::OnNetworksChangedEvent,
+      base::Bind(&NetworkingPrivateHandler::WiFiNetworksChangedEvent,
                  base::Unretained(this)));
   wifi_service_->SetNetworkListChangedObserver(
-      base::Bind(&NetworkingPrivateHandler::OnNetworkListChangedEvent,
+      base::Bind(&NetworkingPrivateHandler::WiFiNetworkListChangedEvent,
                  base::Unretained(this)));
 }
 
-void NetworkingPrivateHandler::OnApiError(
+void NetworkingPrivateHandler::WiFiApiError(
     int message_id,
     const std::string& error_name,
     scoped_ptr<base::DictionaryValue> error_data) {
   Send(new NetworkingPrivateMsg_API_Error(message_id, error_name, *error_data));
 }
 
 void NetworkingPrivateHandler::OnGetPropertiesStart(
     int message_id,
     const std::string& network_guid) {
   wifi_service_->GetProperties(
       network_guid,
-      base::Bind(&NetworkingPrivateHandler::OnGetPropertiesSucceeded,
+      base::Bind(&NetworkingPrivateHandler::WiFiGetPropertiesSucceeded,
                  base::Unretained(this),
                  message_id),
-      base::Bind(&NetworkingPrivateHandler::OnApiError,
+      base::Bind(&NetworkingPrivateHandler::WiFiApiError,
                  base::Unretained(this),
                  message_id));
 }
 
-void NetworkingPrivateHandler::OnGetPropertiesSucceeded(
+void NetworkingPrivateHandler::WiFiGetPropertiesSucceeded(
     int message_id,
     const std::string& network_guid,
     const WiFiService::NetworkProperties& properties) {
   scoped_ptr<DictionaryValue> properties_value(properties.ToValue(false));
   Send(new NetworkingPrivateMsg_GetProperties_Succeeded(
       message_id, network_guid, *properties_value));
 }
 
 void NetworkingPrivateHandler::OnSetPropertiesStart(
     int message_id,
     const std::string& network_guid,
     const base::DictionaryValue& properties) {
   wifi_service_->SetProperties(
       network_guid,
       properties,
-      base::Bind(&NetworkingPrivateHandler::OnSetPropertiesSucceeded,
+      base::Bind(&NetworkingPrivateHandler::WiFiSetPropertiesSucceeded,
                  base::Unretained(this),
                  message_id),
-      base::Bind(&NetworkingPrivateHandler::OnApiError,
+      base::Bind(&NetworkingPrivateHandler::WiFiApiError,
                  base::Unretained(this),
                  message_id));
 }
 
-void NetworkingPrivateHandler::OnSetPropertiesSucceeded(
+void NetworkingPrivateHandler::WiFiSetPropertiesSucceeded(
     int message_id,
     const std::string& network_guid) {
   Send(new NetworkingPrivateMsg_SetProperties_Succeeded(message_id,
                                                         network_guid));
 }
 
 void NetworkingPrivateHandler::OnStartConnectStart(
     int message_id,
     const std::string& network_guid) {
   wifi_service_->StartConnect(
       network_guid,
-      base::Bind(&NetworkingPrivateHandler::OnStartConnectSucceeded,
+      base::Bind(&NetworkingPrivateHandler::WiFiStartConnectSucceeded,
                  base::Unretained(this),
                  message_id),
-      base::Bind(&NetworkingPrivateHandler::OnApiError,
+      base::Bind(&NetworkingPrivateHandler::WiFiApiError,
                  base::Unretained(this),
                  message_id));
 }
 
-void NetworkingPrivateHandler::OnStartConnectSucceeded(
+void NetworkingPrivateHandler::WiFiStartConnectSucceeded(
     int message_id,
     const std::string& network_guid) {
   Send(new NetworkingPrivateMsg_StartConnect_Succeeded(message_id,
                                                        network_guid));
 }
 
 void NetworkingPrivateHandler::OnStartDisconnectStart(
     int message_id,
     const std::string& network_guid) {
   wifi_service_->StartDisconnect(
       network_guid,
-      base::Bind(&NetworkingPrivateHandler::OnStartDisconnectSucceeded,
+      base::Bind(&NetworkingPrivateHandler::WiFiStartDisconnectSucceeded,
                  base::Unretained(this),
                  message_id),
-      base::Bind(&NetworkingPrivateHandler::OnApiError,
+      base::Bind(&NetworkingPrivateHandler::WiFiApiError,
                  base::Unretained(this),
                  message_id));
 }
 
-void NetworkingPrivateHandler::OnStartDisconnectSucceeded(
+void NetworkingPrivateHandler::WiFiStartDisconnectSucceeded(
     int message_id,
     const std::string& network_guid) {
   Send(new NetworkingPrivateMsg_StartDisconnect_Succeeded(message_id,
                                                           network_guid));
 }
 
 void NetworkingPrivateHandler::OnRequestNetworkScan() {
   wifi_service_->GetVisibleNetworks(
-      base::Bind(&NetworkingPrivateHandler::OnNetworkScanSucceeded,
+      base::Bind(&NetworkingPrivateHandler::WiFiNetworkScanSucceeded,
                  base::Unretained(this)),
       base::Bind(
-          &NetworkingPrivateHandler::OnApiError, base::Unretained(this), 0));
+          &NetworkingPrivateHandler::WiFiApiError, base::Unretained(this), 0));
   wifi_service_->RequestNetworkScan();
 }
 
-void NetworkingPrivateHandler::OnNetworkScanSucceeded(
+void NetworkingPrivateHandler::WiFiNetworkScanSucceeded(
     const WiFiService::NetworkList& network_list) {
   std::vector<std::string> list;
   for (WiFiService::NetworkList::const_iterator it = network_list.begin();
        it != network_list.end();
        ++it) {
     list.push_back(it->guid);
   }
 
   Send(new NetworkingPrivateMsg_NetworkListChanged_Event(list));
 }
 
 void NetworkingPrivateHandler::OnGetVisibleNetworks(int message_id) {
   wifi_service_->GetVisibleNetworks(
-      base::Bind(&NetworkingPrivateHandler::OnGetVisibleNetworksSucceeded,
+      base::Bind(&NetworkingPrivateHandler::WiFiGetVisibleNetworksSucceeded,
                  base::Unretained(this),
                  message_id),
-      base::Bind(&NetworkingPrivateHandler::OnApiError,
+      base::Bind(&NetworkingPrivateHandler::WiFiApiError,
                  base::Unretained(this),
                  message_id));
 }
 
-void NetworkingPrivateHandler::OnGetVisibleNetworksSucceeded(
+void NetworkingPrivateHandler::WiFiGetVisibleNetworksSucceeded(
     int message_id,
     const WiFiService::NetworkList& network_list) {
   scoped_ptr<ListValue> visible_networks(new ListValue());
   for (WiFiService::NetworkList::const_iterator it = network_list.begin();
        it != network_list.end();
        ++it) {
     scoped_ptr<DictionaryValue> network(it->ToValue(true));
     visible_networks->Append(network.release());
   }
   Send(new NetworkingPrivateMsg_GetVisibleNetworksSucceeded(message_id,
                                                             *visible_networks));
 }
 
 // static
 bool NetworkingPrivateHandler::Send(IPC::Message* message) {
   return content::UtilityThread::Get()->Send(message);
 }
 
-void NetworkingPrivateHandler::OnNetworkListChangedEvent(
+void NetworkingPrivateHandler::WiFiNetworkListChangedEvent(
     const WiFiService::NetworkGuidList& network_guid_list) {
   std::vector<std::string> networks(network_guid_list.begin(),
                                     network_guid_list.end());
   Send(new NetworkingPrivateMsg_NetworkListChanged_Event(networks));
 }
 
-void NetworkingPrivateHandler::OnNetworksChangedEvent(
+void NetworkingPrivateHandler::WiFiNetworksChangedEvent(
     const WiFiService::NetworkGuidList& network_guid_list) {
   std::vector<std::string> networks(network_guid_list.begin(),
                                     network_guid_list.end());
   Send(new NetworkingPrivateMsg_NetworksChanged_Event(networks));
 }
 
 }  // namespace chrome