Move networking_private to src/extensions

extensions/browser/api/networking_private/networking_private_event_router_chromeos.cc

Index: extensions/browser/api/networking_private/networking_private_event_router_chromeos.cc
diff --git a/chrome/browser/extensions/api/networking_private/networking_private_event_router_chromeos.cc b/extensions/browser/api/networking_private/networking_private_event_router_chromeos.cc
similarity index 67%
rename from chrome/browser/extensions/api/networking_private/networking_private_event_router_chromeos.cc
rename to extensions/browser/api/networking_private/networking_private_event_router_chromeos.cc
index b827f165883dd532e1fadd3ac8bce3db3534393a..3bf43298666cdd1c7ba04c17aadfdb2c9499e3d6 100644
--- a/chrome/browser/extensions/api/networking_private/networking_private_event_router_chromeos.cc
+++ b/extensions/browser/api/networking_private/networking_private_event_router_chromeos.cc
@@ -2,13 +2,9 @@
 // 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_event_router.h"
+#include "extensions/browser/api/networking_private/networking_private_event_router.h"
 
 #include "base/json/json_writer.h"
-#include "chrome/browser/browser_process.h"
-#include "chrome/browser/extensions/api/networking_private/networking_private_api.h"
-#include "chrome/browser/extensions/event_router_forwarder.h"
-#include "chrome/common/extensions/api/networking_private.h"
 #include "chromeos/network/network_event_log.h"
 #include "chromeos/network/network_state.h"
 #include "chromeos/network/network_state_handler.h"
@@ -19,7 +15,9 @@
 #include "components/keyed_service/content/browser_context_dependency_manager.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/extension_system.h"
+#include "extensions/common/api/networking_private.h"
 #include "third_party/cros_system_api/dbus/service_constants.h"
 
 using chromeos::NetworkHandler;
@@ -34,8 +32,7 @@ class NetworkingPrivateEventRouterImpl
       public chromeos::NetworkStateHandlerObserver,
       public NetworkPortalDetector::Observer {
  public:
-  explicit NetworkingPrivateEventRouterImpl(
-      content::BrowserContext* browser_context);
+  explicit NetworkingPrivateEventRouterImpl(content::BrowserContext* context);
   ~NetworkingPrivateEventRouterImpl() override;
 
  protected:
@@ -62,27 +59,28 @@ class NetworkingPrivateEventRouterImpl
   // Otherwise, we want to unregister and not be listening to network changes.
   void StartOrStopListeningForNetworkChanges();
 
-  content::BrowserContext* browser_context_;
+  content::BrowserContext* context_;
   bool listening_;
 
   DISALLOW_COPY_AND_ASSIGN(NetworkingPrivateEventRouterImpl);
 };
 
 NetworkingPrivateEventRouterImpl::NetworkingPrivateEventRouterImpl(
-    content::BrowserContext* browser_context)
-    : browser_context_(browser_context), listening_(false) {
+    content::BrowserContext* context)
+    : context_(context), listening_(false) {
   // Register with the event router so we know when renderers are listening to
   // our events. We first check and see if there *is* an event router, because
-  // some unit tests try to create all profile services, but don't initialize
+  // some unit tests try to create all context services, but don't initialize
   // the event router first.
-  EventRouter* event_router = EventRouter::Get(browser_context_);
+  EventRouter* event_router = EventRouter::Get(context_);
   if (event_router) {
     event_router->RegisterObserver(
-        this, api::networking_private::OnNetworksChanged::kEventName);
+        this, core_api::networking_private::OnNetworksChanged::kEventName);
     event_router->RegisterObserver(
-        this, api::networking_private::OnNetworkListChanged::kEventName);
+        this, core_api::networking_private::OnNetworkListChanged::kEventName);
     event_router->RegisterObserver(
-        this, api::networking_private::OnPortalDetectionCompleted::kEventName);
+        this,
+        core_api::networking_private::OnPortalDetectionCompleted::kEventName);
     StartOrStopListeningForNetworkChanges();
   }
 }
@@ -93,15 +91,15 @@ NetworkingPrivateEventRouterImpl::~NetworkingPrivateEventRouterImpl() {
 
 void NetworkingPrivateEventRouterImpl::Shutdown() {
   // Unregister with the event router. We first check and see if there *is* an
-  // event router, because some unit tests try to shutdown all profile services,
+  // event router, because some unit tests try to shutdown all context services,
   // but didn't initialize the event router first.
-  EventRouter* event_router = EventRouter::Get(browser_context_);
+  EventRouter* event_router = EventRouter::Get(context_);
   if (event_router)
     event_router->UnregisterObserver(this);
 
   if (listening_) {
-    NetworkHandler::Get()->network_state_handler()->RemoveObserver(
-        this, FROM_HERE);
+    NetworkHandler::Get()->network_state_handler()->RemoveObserver(this,
+                                                                   FROM_HERE);
   }
   listening_ = false;
 }
@@ -120,23 +118,23 @@ void NetworkingPrivateEventRouterImpl::OnListenerRemoved(
 }
 
 void NetworkingPrivateEventRouterImpl::StartOrStopListeningForNetworkChanges() {
-  EventRouter* event_router = EventRouter::Get(browser_context_);
+  EventRouter* event_router = EventRouter::Get(context_);
   bool should_listen =
       event_router->HasEventListener(
-          api::networking_private::OnNetworksChanged::kEventName) ||
+          core_api::networking_private::OnNetworksChanged::kEventName) ||
       event_router->HasEventListener(
-          api::networking_private::OnNetworkListChanged::kEventName) ||
+          core_api::networking_private::OnNetworkListChanged::kEventName) ||
       event_router->HasEventListener(
-          api::networking_private::OnPortalDetectionCompleted::kEventName);
+          core_api::networking_private::OnPortalDetectionCompleted::kEventName);
 
   if (should_listen && !listening_) {
-    NetworkHandler::Get()->network_state_handler()->AddObserver(
-        this, FROM_HERE);
+    NetworkHandler::Get()->network_state_handler()->AddObserver(this,
+                                                                FROM_HERE);
     if (chromeos::NetworkPortalDetector::IsInitialized())
       NetworkPortalDetector::Get()->AddObserver(this);
   } else if (!should_listen && listening_) {
-    NetworkHandler::Get()->network_state_handler()->RemoveObserver(
-        this, FROM_HERE);
+    NetworkHandler::Get()->network_state_handler()->RemoveObserver(this,
+                                                                   FROM_HERE);
     if (chromeos::NetworkPortalDetector::IsInitialized())
       NetworkPortalDetector::Get()->RemoveObserver(this);
   }
@@ -144,12 +142,12 @@ void NetworkingPrivateEventRouterImpl::StartOrStopListeningForNetworkChanges() {
 }
 
 void NetworkingPrivateEventRouterImpl::NetworkListChanged() {
-  EventRouter* event_router = EventRouter::Get(browser_context_);
+  EventRouter* event_router = EventRouter::Get(context_);
   NetworkStateHandler::NetworkStateList networks;
   NetworkHandler::Get()->network_state_handler()->GetVisibleNetworkList(
       &networks);
   if (!event_router->HasEventListener(
-           api::networking_private::OnNetworkListChanged::kEventName)) {
+          core_api::networking_private::OnNetworkListChanged::kEventName)) {
     // TODO(stevenjb): Remove logging once crbug.com/256881 is fixed
     // (or at least reduce to LOG_DEBUG). Same with NET_LOG events below.
     NET_LOG_EVENT("NetworkingPrivate.NetworkListChanged: No Listeners", "");
@@ -161,34 +159,34 @@ void NetworkingPrivateEventRouterImpl::NetworkListChanged() {
   std::vector<std::string> changes;
   for (NetworkStateHandler::NetworkStateList::const_iterator iter =
            networks.begin();
-       iter != networks.end();
-       ++iter) {
+       iter != networks.end(); ++iter) {
     changes.push_back((*iter)->guid());
   }
 
   scoped_ptr<base::ListValue> args(
-      api::networking_private::OnNetworkListChanged::Create(changes));
-  scoped_ptr<Event> extension_event(new Event(
-      api::networking_private::OnNetworkListChanged::kEventName, args.Pass()));
+      core_api::networking_private::OnNetworkListChanged::Create(changes));
+  scoped_ptr<Event> extension_event(
+      new Event(core_api::networking_private::OnNetworkListChanged::kEventName,
+                args.Pass()));
   event_router->BroadcastEvent(extension_event.Pass());
 }
 
 void NetworkingPrivateEventRouterImpl::NetworkPropertiesUpdated(
     const NetworkState* network) {
-  EventRouter* event_router = EventRouter::Get(browser_context_);
+  EventRouter* event_router = EventRouter::Get(context_);
   if (!event_router->HasEventListener(
-           api::networking_private::OnNetworksChanged::kEventName)) {
+          core_api::networking_private::OnNetworksChanged::kEventName)) {
     NET_LOG_EVENT("NetworkingPrivate.NetworkPropertiesUpdated: No Listeners",
                   network->path());
     return;
   }
-  NET_LOG_EVENT("NetworkingPrivate.NetworkPropertiesUpdated",
-                network->path());
+  NET_LOG_EVENT("NetworkingPrivate.NetworkPropertiesUpdated", network->path());
   scoped_ptr<base::ListValue> args(
-      api::networking_private::OnNetworksChanged::Create(
+      core_api::networking_private::OnNetworksChanged::Create(
           std::vector<std::string>(1, network->guid())));
-  scoped_ptr<Event> extension_event(new Event(
-      api::networking_private::OnNetworksChanged::kEventName, args.Pass()));
+  scoped_ptr<Event> extension_event(
+      new Event(core_api::networking_private::OnNetworksChanged::kEventName,
+                args.Pass()));
   event_router->BroadcastEvent(extension_event.Pass());
 }
 
@@ -197,33 +195,34 @@ void NetworkingPrivateEventRouterImpl::OnPortalDetectionCompleted(
     const NetworkPortalDetector::CaptivePortalState& state) {
   const std::string path = network ? network->guid() : std::string();
 
-  EventRouter* event_router = EventRouter::Get(browser_context_);
+  EventRouter* event_router = EventRouter::Get(context_);
   if (!event_router->HasEventListener(
-          api::networking_private::OnPortalDetectionCompleted::kEventName)) {
+          core_api::networking_private::OnPortalDetectionCompleted::
+              kEventName)) {
     NET_LOG_EVENT("NetworkingPrivate.OnPortalDetectionCompleted: No Listeners",
                   path);
     return;
   }
   NET_LOG_EVENT("NetworkingPrivate.OnPortalDetectionCompleted", path);
 
-  api::networking_private::CaptivePortalStatus status =
-      api::networking_private::CAPTIVE_PORTAL_STATUS_UNKNOWN;
+  core_api::networking_private::CaptivePortalStatus status =
+      core_api::networking_private::CAPTIVE_PORTAL_STATUS_UNKNOWN;
   switch (state.status) {
     case NetworkPortalDetector::CAPTIVE_PORTAL_STATUS_UNKNOWN:
-      status = api::networking_private::CAPTIVE_PORTAL_STATUS_UNKNOWN;
+      status = core_api::networking_private::CAPTIVE_PORTAL_STATUS_UNKNOWN;
       break;
     case NetworkPortalDetector::CAPTIVE_PORTAL_STATUS_OFFLINE:
-      status = api::networking_private::CAPTIVE_PORTAL_STATUS_OFFLINE;
+      status = core_api::networking_private::CAPTIVE_PORTAL_STATUS_OFFLINE;
       break;
     case NetworkPortalDetector::CAPTIVE_PORTAL_STATUS_ONLINE:
-      status = api::networking_private::CAPTIVE_PORTAL_STATUS_ONLINE;
+      status = core_api::networking_private::CAPTIVE_PORTAL_STATUS_ONLINE;
       break;
     case NetworkPortalDetector::CAPTIVE_PORTAL_STATUS_PORTAL:
-      status = api::networking_private::CAPTIVE_PORTAL_STATUS_PORTAL;
+      status = core_api::networking_private::CAPTIVE_PORTAL_STATUS_PORTAL;
       break;
     case NetworkPortalDetector::CAPTIVE_PORTAL_STATUS_PROXY_AUTH_REQUIRED:
       status =
-          api::networking_private::CAPTIVE_PORTAL_STATUS_PROXYAUTHREQUIRED;
+          core_api::networking_private::CAPTIVE_PORTAL_STATUS_PROXYAUTHREQUIRED;
       break;
     default:
       NOTREACHED();
@@ -231,17 +230,17 @@ void NetworkingPrivateEventRouterImpl::OnPortalDetectionCompleted(
   }
 
   scoped_ptr<base::ListValue> args(
-      api::networking_private::OnPortalDetectionCompleted::Create(
-          path, status));
-  scoped_ptr<Event> extension_event(
-      new Event(api::networking_private::OnPortalDetectionCompleted::kEventName,
-                args.Pass()));
+      core_api::networking_private::OnPortalDetectionCompleted::Create(path,
+                                                                       status));
+  scoped_ptr<Event> extension_event(new Event(
+      core_api::networking_private::OnPortalDetectionCompleted::kEventName,
+      args.Pass()));
   event_router->BroadcastEvent(extension_event.Pass());
 }
 
 NetworkingPrivateEventRouter* NetworkingPrivateEventRouter::Create(
-    content::BrowserContext* browser_context) {
-  return new NetworkingPrivateEventRouterImpl(browser_context);
+    content::BrowserContext* context) {
+  return new NetworkingPrivateEventRouterImpl(context);
 }
 
 }  // namespace extensions