Address some TODOs for ChooserBubbleDelegate class

chrome/browser/usb/usb_chooser_bubble_delegate.cc

 // Copyright 2015 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/browser/usb/usb_chooser_bubble_delegate.h"
 
 #include <stddef.h>
+#include <iterator>
 #include <utility>
 
 #include "base/bind.h"
 #include "base/stl_util.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/usb/usb_chooser_context.h"
 #include "chrome/browser/usb/usb_chooser_context_factory.h"
 #include "components/bubble/bubble_controller.h"
 #include "content/public/browser/render_frame_host.h"
 #include "content/public/browser/web_contents.h"
@@ skipping 52 matching lines @@
 
   usb_service->GetDevices(base::Bind(
       &UsbChooserBubbleDelegate::GotUsbDeviceList, weak_factory_.GetWeakPtr()));
 }
 
 UsbChooserBubbleDelegate::~UsbChooserBubbleDelegate() {
   if (!callback_.is_null())
     callback_.Run(nullptr);
 }
 
-const std::vector<base::string16>& UsbChooserBubbleDelegate::GetOptions()
-    const {
-  return devices_names_;
+size_t UsbChooserBubbleDelegate::NumOptions() const {
+  return devices_.size();
 }
 
-void UsbChooserBubbleDelegate::Select(int index) {
-  size_t idx = static_cast<size_t>(index);
-  size_t num_options = devices_.size();
-  DCHECK_LT(idx, num_options);
-  if (idx < num_options) {
-    content::WebContents* web_contents =
-        content::WebContents::FromRenderFrameHost(render_frame_host_);
-    GURL embedding_origin =
-        web_contents->GetMainFrame()->GetLastCommittedURL().GetOrigin();
-    Profile* profile =
-        Profile::FromBrowserContext(web_contents->GetBrowserContext());
-    UsbChooserContext* chooser_context =
-        UsbChooserContextFactory::GetForProfile(profile);
-    chooser_context->GrantDevicePermission(
-        render_frame_host_->GetLastCommittedURL().GetOrigin(), embedding_origin,
-        devices_[idx]->guid());
+const base::string16& UsbChooserBubbleDelegate::GetOption(size_t index) const {
+  DCHECK_LT(index, devices_.size());
+  return devices_[index].second;
+}
 
-    device::usb::DeviceInfoPtr device_info_ptr =
-        device::usb::DeviceInfo::From(*devices_[idx]);
-    callback_.Run(std::move(device_info_ptr));
-  } else {
-    callback_.Run(nullptr);
-  }
+void UsbChooserBubbleDelegate::Select(size_t index) {
+  DCHECK_LT(index, devices_.size());
+  content::WebContents* web_contents =
+      content::WebContents::FromRenderFrameHost(render_frame_host_);
+  GURL embedding_origin =
+      web_contents->GetMainFrame()->GetLastCommittedURL().GetOrigin();
+  Profile* profile =
+      Profile::FromBrowserContext(web_contents->GetBrowserContext());
+  UsbChooserContext* chooser_context =
+      UsbChooserContextFactory::GetForProfile(profile);
+  chooser_context->GrantDevicePermission(
+      render_frame_host_->GetLastCommittedURL().GetOrigin(), embedding_origin,
+      devices_[index].first->guid());
+
+  device::usb::DeviceInfoPtr device_info_ptr =
+      device::usb::DeviceInfo::From(*devices_[index].first);
+  callback_.Run(std::move(device_info_ptr));
   callback_.reset();  // Reset |callback_| so that it is only run once.
 
   if (bubble_controller_)
     bubble_controller_->CloseBubble(BUBBLE_CLOSE_ACCEPTED);
 }
 
 void UsbChooserBubbleDelegate::Cancel() {
   if (bubble_controller_)
     bubble_controller_->CloseBubble(BUBBLE_CLOSE_CANCELED);
 }
 
 void UsbChooserBubbleDelegate::Close() {}
 
 void UsbChooserBubbleDelegate::OnDeviceAdded(
     scoped_refptr<device::UsbDevice> device) {
-  DCHECK(!ContainsValue(devices_, device));
   if (device::UsbDeviceFilter::MatchesAny(device, filters_) &&
       FindOriginInDescriptorSet(
           device->webusb_allowed_origins(),
           render_frame_host_->GetLastCommittedURL().GetOrigin())) {
-    devices_.push_back(device);
-    devices_names_.push_back(device->product_string());
+    devices_.push_back(std::make_pair(device, device->product_string()));
     if (observer())
-      observer()->OnOptionAdded(static_cast<int>(devices_names_.size()) - 1);
+      observer()->OnOptionAdded(devices_.size() - 1);
   }
 }
 
 void UsbChooserBubbleDelegate::OnDeviceRemoved(
     scoped_refptr<device::UsbDevice> device) {

[Peter Kasting, 2016/01/04 21:02:52]

Same comments in this function as in the other file

[juncai, 2016/01/04 22:44:47]

Done.

-  auto iter = std::find(devices_.begin(), devices_.end(), device);
-  if (iter != devices_.end()) {
-    int index = iter - devices_.begin();
-    devices_.erase(iter);
-    devices_names_.erase(devices_names_.begin() + index);
-    if (observer())
-      observer()->OnOptionRemoved(index);
+  for (auto it = devices_.begin(), end = devices_.end(); it != end; ++it) {
+    if (it->first == device) {
+      size_t index = std::distance(devices_.begin(), it);
+      devices_.erase(it);
+      if (observer())
+        observer()->OnOptionRemoved(index);
+      break;
+    }
   }
 }
 
 // Get a list of devices that can be shown in the chooser bubble UI for
 // user to grant permsssion.
 void UsbChooserBubbleDelegate::GotUsbDeviceList(
     const std::vector<scoped_refptr<device::UsbDevice>>& devices) {
   for (const auto& device : devices) {
     if (device::UsbDeviceFilter::MatchesAny(device, filters_) &&
         FindOriginInDescriptorSet(
             device->webusb_allowed_origins(),
             render_frame_host_->GetLastCommittedURL().GetOrigin())) {
-      devices_.push_back(device);
-      devices_names_.push_back(device->product_string());
+      devices_.push_back(std::make_pair(device, device->product_string()));
     }
   }
   if (observer())
     observer()->OnOptionsInitialized();
 }
 
 void UsbChooserBubbleDelegate::set_bubble_controller(
     BubbleReference bubble_controller) {
   bubble_controller_ = bubble_controller;
 }