Remove unused fields from //content.

content/browser/bluetooth/bluetooth_dispatcher_host.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.
 
 // ID Not In Map Note:
 // A service, characteristic, or descriptor ID not in the corresponding
 // BluetoothDispatcherHost map [service_to_device_, characteristic_to_service_,
 // descriptor_to_characteristic_] implies a hostile renderer because a renderer
 // obtains the corresponding ID from this class and it will be added to the map
 // at that time.
@@ skipping 350 matching lines @@
   // Clear adapter, releasing observer references.
   set_adapter(scoped_refptr<device::BluetoothAdapter>());
 }
 
 // Stores information associated with an in-progress requestDevice call. This
 // will include the state of the active chooser dialog in a future patch.
 struct BluetoothDispatcherHost::RequestDeviceSession {
  public:
   RequestDeviceSession(int thread_id,
                        int request_id,
-                       int frame_routing_id,

[ncarter (slow), 2016/04/14 17:37:36]

My understanding is that the bluetooth code is in the process of migrating to be
RFH-based. So I don't know that removing this is okay -- we may just be creating
work.

Could you loop ortuno@ in for an opinion on this file?

[ortuno, 2016/04/14 17:53:53]

This is OK. We used to save the routing id so we could get the origin but now
that we save the origin in the session we don't need the routing it.

                        url::Origin origin,
                        const std::vector<BluetoothScanFilter>& filters,
                        const std::vector<BluetoothUUID>& optional_services)
       : thread_id(thread_id),
         request_id(request_id),
-        frame_routing_id(frame_routing_id),
         origin(origin),
         filters(filters),
         optional_services(optional_services) {}
 
   void AddFilteredDevice(const device::BluetoothDevice& device) {
     if (chooser && MatchesFilters(device, filters)) {
       chooser->AddDevice(device.GetAddress(), device.GetName());
     }
   }
 
   std::unique_ptr<device::BluetoothDiscoveryFilter> ComputeScanFilter() const {
     std::set<BluetoothUUID> services;
     for (const BluetoothScanFilter& filter : filters) {
       services.insert(filter.services.begin(), filter.services.end());
     }
     std::unique_ptr<device::BluetoothDiscoveryFilter> discovery_filter(
         new device::BluetoothDiscoveryFilter(
             device::BluetoothDiscoveryFilter::TRANSPORT_DUAL));
     for (const BluetoothUUID& service : services) {
       discovery_filter->AddUUID(service);
     }
     return discovery_filter;
   }
 
   const int thread_id;
   const int request_id;
-  const int frame_routing_id;
   const url::Origin origin;
   const std::vector<BluetoothScanFilter> filters;
   const std::vector<BluetoothUUID> optional_services;
   std::unique_ptr<BluetoothChooser> chooser;
   std::unique_ptr<device::BluetoothDiscoverySession> discovery_session;
 };
 
 BluetoothDispatcherHost::CacheQueryResult::CacheQueryResult() {}
 
 BluetoothDispatcherHost::CacheQueryResult::CacheQueryResult(
@@ skipping 838 matching lines @@
           thread_id, request_id,
           WebBluetoothError::CHOOSER_NOT_SHOWN_API_GLOBALLY_DISABLED));
       return;
     }
     case ContentBrowserClient::AllowWebBluetoothResult::ALLOW:
       break;
   }
 
   // Create storage for the information that backs the chooser, and show the
   // chooser.
-  RequestDeviceSession* const session = new RequestDeviceSession(
-      thread_id, request_id, frame_routing_id, requesting_origin, filters,
-      optional_services_blacklist_filtered);
+  RequestDeviceSession* const session =
+      new RequestDeviceSession(thread_id, request_id, requesting_origin,
+                               filters, optional_services_blacklist_filtered);
   int chooser_id = request_device_sessions_.Add(session);
 
   BluetoothChooser::EventHandler chooser_event_handler =
       base::Bind(&BluetoothDispatcherHost::OnBluetoothChooserEvent,
                  weak_ptr_on_ui_thread_, chooser_id);
   if (WebContentsDelegate* delegate = web_contents->GetDelegate()) {
     session->chooser =
         delegate->RunBluetoothChooser(render_frame_host, chooser_event_handler);
   }
   if (!session->chooser) {
@@ skipping 401 matching lines @@
 
 bool BluetoothDispatcherHost::CanFrameAccessCharacteristicInstance(
     int frame_routing_id,
     const std::string& characteristic_instance_id) {
   return QueryCacheForCharacteristic(GetOrigin(frame_routing_id),
                                      characteristic_instance_id)
              .outcome != CacheQueryOutcome::BAD_RENDERER;
 }
 
 }  // namespace content