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"
@@ skipping 324 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::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