Update device permissions dialog ui for Chrome apps and extensions

extensions/browser/api/device_permissions_prompt.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/device_permissions_prompt.h"
 
 #include <utility>
 
 #include "base/bind.h"
 #include "base/i18n/message_formatter.h"
 #include "base/scoped_observer.h"
 #include "base/strings/stringprintf.h"
 #include "base/strings/utf_string_conversions.h"
 #include "build/build_config.h"
 #include "device/base/device_client.h"
 #include "device/hid/hid_device_filter.h"
 #include "device/hid/hid_device_info.h"
 #include "device/hid/hid_service.h"
 #include "device/usb/usb_device.h"
 #include "device/usb/usb_device_filter.h"
 #include "device/usb/usb_ids.h"
 #include "device/usb/usb_service.h"
 #include "extensions/browser/api/device_permissions_manager.h"
 #include "extensions/common/extension.h"
-#include "extensions/strings/grit/extensions_strings.h"
 #include "ui/base/l10n/l10n_util.h"
 
 #if defined(OS_CHROMEOS)
 #include "chromeos/dbus/dbus_thread_manager.h"
 #include "chromeos/dbus/permission_broker_client.h"
 #include "device/hid/hid_device_info_linux.h"
 #endif  // defined(OS_CHROMEOS)
 
 using device::HidDeviceFilter;
 using device::HidService;
@@ skipping 56 matching lines @@
     if (observer) {
       UsbService* service = device::DeviceClient::Get()->GetUsbService();
       if (service && !service_observer_.IsObserving(service)) {
         service->GetDevices(
             base::Bind(&UsbDevicePermissionsPrompt::OnDevicesEnumerated, this));
         service_observer_.Add(service);
       }
     }
   }
 
-  base::string16 GetHeading() const override {
-    return l10n_util::GetSingleOrMultipleStringUTF16(
-        IDS_USB_DEVICE_PERMISSIONS_PROMPT_TITLE, multiple());
-  }
-
   void Dismissed() override {
     DevicePermissionsManager* permissions_manager =
         DevicePermissionsManager::Get(browser_context());
     std::vector<scoped_refptr<UsbDevice>> devices;
     for (const auto& device : devices_) {
       if (device->granted()) {
         const UsbDeviceInfo* usb_device =
             static_cast<const UsbDeviceInfo*>(device.get());
         devices.push_back(usb_device->device());
         if (permissions_manager) {
@@ skipping 16 matching lines @@
     device->CheckUsbAccess(
         base::Bind(&UsbDevicePermissionsPrompt::AddCheckedDevice, this,
                    base::Passed(&device_info)));
   }
 
   void OnDeviceRemoved(scoped_refptr<UsbDevice> device) override {
     for (auto it = devices_.begin(); it != devices_.end(); ++it) {
       const UsbDeviceInfo* entry =
           static_cast<const UsbDeviceInfo*>((*it).get());
       if (entry->device() == device) {
+        size_t index = it - devices_.begin();
+        base::string16 device_name = (*it)->name();
         devices_.erase(it);
-        if (observer()) {
-          observer()->OnDevicesChanged();
-        }
+        if (observer())
+          observer()->OnDeviceRemoved(index, device_name);
         return;
       }
     }
   }
 
   void OnDevicesEnumerated(
       const std::vector<scoped_refptr<UsbDevice>>& devices) {
     for (const auto& device : devices) {
       OnDeviceAdded(device);
     }
@@ skipping 49 matching lines @@
     if (observer) {
       HidService* service = device::DeviceClient::Get()->GetHidService();
       if (service && !service_observer_.IsObserving(service)) {
         service->GetDevices(
             base::Bind(&HidDevicePermissionsPrompt::OnDevicesEnumerated, this));
         service_observer_.Add(service);
       }
     }
   }
 
-  base::string16 GetHeading() const override {
-    return l10n_util::GetSingleOrMultipleStringUTF16(
-        IDS_HID_DEVICE_PERMISSIONS_PROMPT_TITLE, multiple());
-  }
-
   void Dismissed() override {
     DevicePermissionsManager* permissions_manager =
         DevicePermissionsManager::Get(browser_context());
     std::vector<scoped_refptr<device::HidDeviceInfo>> devices;
     for (const auto& device : devices_) {
       if (device->granted()) {
         const HidDeviceInfo* hid_device =
             static_cast<const HidDeviceInfo*>(device.get());
         devices.push_back(hid_device->device());
         if (permissions_manager) {
@@ skipping 26 matching lines @@
       AddCheckedDevice(std::move(device_info), true);
 #endif  // defined(OS_CHROMEOS)
     }
   }
 
   void OnDeviceRemoved(scoped_refptr<device::HidDeviceInfo> device) override {
     for (auto it = devices_.begin(); it != devices_.end(); ++it) {
       const HidDeviceInfo* entry =
           static_cast<const HidDeviceInfo*>((*it).get());
       if (entry->device() == device) {
+        size_t index = it - devices_.begin();
+        base::string16 device_name = (*it)->name();
         devices_.erase(it);
-        if (observer()) {
-          observer()->OnDevicesChanged();
-        }
+        if (observer())
+          observer()->OnDeviceRemoved(index, device_name);
         return;
       }
     }
   }
 
   void OnDevicesEnumerated(
       const std::vector<scoped_refptr<device::HidDeviceInfo>>& devices) {
     for (const auto& device : devices) {
       OnDeviceAdded(device);
     }
@@ skipping 27 matching lines @@
 DevicePermissionsPrompt::Prompt::Prompt(const Extension* extension,
                                         content::BrowserContext* context,
                                         bool multiple)
     : extension_(extension), browser_context_(context), multiple_(multiple) {
 }
 
 void DevicePermissionsPrompt::Prompt::SetObserver(Observer* observer) {
   observer_ = observer;
 }
 
-base::string16 DevicePermissionsPrompt::Prompt::GetPromptMessage() const {
-  return base::i18n::MessageFormatter::FormatWithNumberedArgs(
-      l10n_util::GetStringUTF16(IDS_DEVICE_PERMISSIONS_PROMPT),
-      multiple_ ? "multiple" : "single", extension_->name());
-}
-
 base::string16 DevicePermissionsPrompt::Prompt::GetDeviceName(
     size_t index) const {
   DCHECK_LT(index, devices_.size());
   return devices_[index]->name();
 }
 
 base::string16 DevicePermissionsPrompt::Prompt::GetDeviceSerialNumber(
     size_t index) const {
   DCHECK_LT(index, devices_.size());
   return devices_[index]->serial_number();
 }
 
 void DevicePermissionsPrompt::Prompt::GrantDevicePermission(size_t index) {
   DCHECK_LT(index, devices_.size());
   devices_[index]->set_granted();
 }
 
 DevicePermissionsPrompt::Prompt::~Prompt() {
 }
 
 void DevicePermissionsPrompt::Prompt::AddCheckedDevice(
     std::unique_ptr<DeviceInfo> device,
     bool allowed) {
   if (allowed) {
+    base::string16 device_name = device->name();
     devices_.push_back(std::move(device));
-    if (observer_) {
-      observer_->OnDevicesChanged();
-    }
+    if (observer_)
+      observer_->OnDeviceAdded(devices_.size() - 1, device_name);
   }
 }
 
 DevicePermissionsPrompt::DevicePermissionsPrompt(
     content::WebContents* web_contents)
     : web_contents_(web_contents) {
 }
 
 DevicePermissionsPrompt::~DevicePermissionsPrompt() {
 }
@@ skipping 32 matching lines @@
 // static
 scoped_refptr<DevicePermissionsPrompt::Prompt>
 DevicePermissionsPrompt::CreateUsbPromptForTest(const Extension* extension,
                                                 bool multiple) {
   return make_scoped_refptr(new UsbDevicePermissionsPrompt(
       extension, nullptr, multiple, std::vector<UsbDeviceFilter>(),
       base::Bind(&NoopUsbCallback)));
 }
 
 }  // namespace extensions