Make vpn destroyConfig generate disconnect message for connected configuration

extensions/browser/api/vpn_provider/vpn_service.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 "extensions/browser/api/vpn_provider/vpn_service.h"
 
 #include <stdint.h>
 #include <vector>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/guid.h"
 #include "base/location.h"
 #include "base/logging.h"
 #include "base/stl_util.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_util.h"
 #include "base/values.h"
 #include "chromeos/dbus/shill_third_party_vpn_driver_client.h"
 #include "chromeos/dbus/shill_third_party_vpn_observer.h"
 #include "chromeos/network/network_configuration_handler.h"
 #include "chromeos/network/network_profile.h"
 #include "chromeos/network/network_profile_handler.h"
 #include "chromeos/network/network_state.h"
 #include "chromeos/network/network_state_handler.h"
 #include "chromeos/network/network_type_pattern.h"
 #include "crypto/sha2.h"
+#include "extensions/browser/app_window/app_window.h"

[bartfab (slow), 2015/03/10 13:28:40]

Nit: No longer needed.

 #include "extensions/browser/event_router.h"
 #include "extensions/browser/extension_registry.h"
 #include "third_party/cros_system_api/dbus/service_constants.h"
 
 namespace chromeos {
 
 namespace {
 
 namespace api_vpn = extensions::core_api::vpn_provider;
 
@@ skipping 92 matching lines @@
   scoped_ptr<base::ListValue> event_args = api_vpn::OnPlatformMessage::Create(
       configuration_name_, platform_message, std::string());
 
   vpn_service_->SendSignalToExtension(
       extension_id_, api_vpn::OnPlatformMessage::kEventName, event_args.Pass());
 }
 
 VpnService::VpnService(
     content::BrowserContext* browser_context,
     const std::string& userid_hash,
+    extensions::AppWindowRegistry* app_window_registry,

[bartfab (slow), 2015/03/10 13:28:40]

Nit: No longer needed.

     extensions::ExtensionRegistry* extension_registry,
     extensions::EventRouter* event_router,
     ShillThirdPartyVpnDriverClient* shill_client,
     NetworkConfigurationHandler* network_configuration_handler,
     NetworkProfileHandler* network_profile_handler,
     NetworkStateHandler* network_state_handler)
     : browser_context_(browser_context),
       userid_hash_(userid_hash),
+      app_window_registry_(app_window_registry),

[bartfab (slow), 2015/03/10 13:28:40]

Nit: No longer needed.

       extension_registry_(extension_registry),
       event_router_(event_router),
       shill_client_(shill_client),
       network_configuration_handler_(network_configuration_handler),
       network_profile_handler_(network_profile_handler),
       network_state_handler_(network_state_handler),
       active_configuration_(nullptr),
       weak_factory_(this) {
+  app_window_registry_->AddObserver(this);

[bartfab (slow), 2015/03/10 13:28:40]

Nit: No longer needed.

   extension_registry_->AddObserver(this);
   network_state_handler_->AddObserver(this, FROM_HERE);
   network_configuration_handler_->AddObserver(this);
 }
 
 VpnService::~VpnService() {
   network_configuration_handler_->RemoveObserver(this);
   network_state_handler_->RemoveObserver(this, FROM_HERE);
   extension_registry_->RemoveObserver(this);
+  app_window_registry_->RemoveObserver(this);

[bartfab (slow), 2015/03/10 13:28:40]

Nit: No longer needed.

   STLDeleteContainerPairSecondPointers(key_to_configuration_map_.begin(),
                                        key_to_configuration_map_.end());
 }
 
 void VpnService::OnConfigurationCreated(const std::string& service_path,
                                         const std::string& profile_path,
                                         const base::DictionaryValue& properties,
                                         Source source) {
 }
 
@@ skipping 160 matching lines @@
                                       const SuccessCallback& success,
                                       const FailureCallback& failure) {
   const std::string key = GetKey(extension_id, configuration_name);
   if (!ContainsKey(key_to_configuration_map_, key)) {
     failure.Run(std::string(), std::string("Unauthorized access."));
     return;
   }
 
   VpnConfiguration* configuration = key_to_configuration_map_[key];
   const std::string service_path = configuration->service_path();
+  if (active_configuration_ == configuration) {
+    configuration->OnPlatformMessage(api_vpn::PLATFORM_MESSAGE_DISCONNECTED);
+  }
   DestroyConfigurationInternal(configuration);
 
   network_configuration_handler_->RemoveConfiguration(
       service_path, NetworkConfigurationObserver::SOURCE_EXTENSION_INSTALL,
       base::Bind(&VpnService::OnRemoveConfigurationSuccess,
                  weak_factory_.GetWeakPtr(), success),
       base::Bind(&VpnService::OnRemoveConfigurationFailure,
                  weak_factory_.GetWeakPtr(), failure));
 }
 
@@ skipping 59 matching lines @@
   }
 
   for (auto& iter : to_be_destroyed) {
     DestroyConfiguration(extension->id(),             // Extension ID
                          iter->configuration_name(),  // Configuration name
                          base::Bind(base::DoNothing),
                          base::Bind(DoNothingFailureCallback));
   }
 }
 
+void VpnService::OnExtensionUnloaded(
+    content::BrowserContext* browser_context,
+    const extensions::Extension* extension,
+    extensions::UnloadedExtensionInfo::Reason reason) {
+  if (browser_context != browser_context_) {
+    NOTREACHED();
+    return;
+  }
+
+  if (active_configuration_ &&
+      active_configuration_->extension_id() == extension->id()) {
+    shill_client_->UpdateConnectionState(
+        active_configuration_->object_path(),
+        static_cast<uint32_t>(api_vpn::VPN_CONNECTION_STATE_FAILURE),
+        base::Bind(base::DoNothing), base::Bind(DoNothingFailureCallback));
+  }
+}
+
+void VpnService::OnAppWindowRemoved(extensions::AppWindow* app_window) {

[bartfab (slow), 2015/03/10 13:28:40]

Nit: As discussed offline, we do not need this.

+  if (active_configuration_ &&
+      active_configuration_->extension_id() == app_window->extension_id()) {
+    shill_client_->UpdateConnectionState(
+        active_configuration_->object_path(),
+        static_cast<uint32_t>(api_vpn::VPN_CONNECTION_STATE_FAILURE),
+        base::Bind(base::DoNothing), base::Bind(DoNothingFailureCallback));
+  }
+}
+
 void VpnService::OnCreateConfigurationSuccess(
     const VpnService::SuccessCallback& callback,
     VpnConfiguration* configuration,
     const std::string& service_path) {
   configuration->set_service_path(service_path);
   service_path_to_configuration_map_[service_path] = configuration;
   shill_client_->AddShillThirdPartyVpnObserver(configuration->object_path(),
                                                configuration);
   callback.Run();
 }
@@ skipping 57 matching lines @@
   delete configuration;
 }
 
 bool VpnService::DoesActiveConfigurationExistAndIsAccessAuthorized(
     const std::string& extension_id) {
   return active_configuration_ &&
          active_configuration_->extension_id() == extension_id;
 }
 
 }  // namespace chromeos