Convert VLOG -> DVLOG in content/browser/bluetooth

content/browser/bluetooth/web_bluetooth_service_impl.cc

 // Copyright 2016 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
 // WebBluetoothServiceImpl map [service_id_to_device_address_,
 // characteristic_id_to_service_id_, 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 227 matching lines @@
 
 void WebBluetoothServiceImpl::GattServicesDiscovered(
     device::BluetoothAdapter* adapter,
     device::BluetoothDevice* device) {
   if (device_chooser_controller_.get()) {
     device_chooser_controller_->AddFilteredDevice(*device);
   }
 
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   const std::string& device_address = device->GetAddress();
-  VLOG(1) << "Services discovered for device: " << device_address;
+  DVLOG(1) << "Services discovered for device: " << device_address;
 
   auto iter = pending_primary_services_requests_.find(device_address);
   if (iter == pending_primary_services_requests_.end()) {
     return;
   }
   std::vector<PrimaryServicesRequestCallback> requests =
       std::move(iter->second);
   pending_primary_services_requests_.erase(iter);
 
   for (const PrimaryServicesRequestCallback& request : requests) {
@@ skipping 74 matching lines @@
 
   const CacheQueryResult query_result = QueryCacheForDevice(device_id);
 
   if (query_result.outcome != CacheQueryOutcome::SUCCESS) {
     RecordConnectGATTOutcome(query_result.outcome);
     callback.Run(query_result.GetWebResult());
     return;
   }
 
   if (connected_devices_->IsConnectedToDeviceWithId(device_id)) {
-    VLOG(1) << "Already connected.";
+    DVLOG(1) << "Already connected.";
     callback.Run(blink::mojom::WebBluetoothResult::SUCCESS);
     return;
   }
 
   // It's possible for WebBluetoothServiceImpl to issue two successive
   // connection requests for which it would get two successive responses
   // and consequently try to insert two BluetoothGattConnections for the
   // same device. WebBluetoothServiceImpl should reject or queue connection
   // requests if there is a pending connection already, but the platform
   // abstraction doesn't currently support checking for pending connections.
   // TODO(ortuno): CHECK that this never happens once the platform
   // abstraction allows to check for pending connections.
   // http://crbug.com/583544
   const base::TimeTicks start_time = base::TimeTicks::Now();
   query_result.device->CreateGattConnection(
       base::Bind(&WebBluetoothServiceImpl::OnCreateGATTConnectionSuccess,
                  weak_ptr_factory_.GetWeakPtr(), device_id, start_time,
                  callback),
       base::Bind(&WebBluetoothServiceImpl::OnCreateGATTConnectionFailed,
                  weak_ptr_factory_.GetWeakPtr(), start_time, callback));
 }
 
 void WebBluetoothServiceImpl::RemoteServerDisconnect(
     const WebBluetoothDeviceId& device_id) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   RecordWebBluetoothFunctionCall(
       UMAWebBluetoothFunction::REMOTE_GATT_SERVER_DISCONNECT);
 
   if (connected_devices_->IsConnectedToDeviceWithId(device_id)) {
-    VLOG(1) << "Disconnecting device: " << device_id.str();
+    DVLOG(1) << "Disconnecting device: " << device_id.str();
     connected_devices_->CloseConnectionToDeviceWithId(device_id);
   }
 }
 
 void WebBluetoothServiceImpl::RemoteServerGetPrimaryServices(
     const WebBluetoothDeviceId& device_id,
     blink::mojom::WebBluetoothGATTQueryQuantity quantity,
     const base::Optional<BluetoothUUID>& services_uuid,
     const RemoteServerGetPrimaryServicesCallback& callback) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
@@ skipping 35 matching lines @@
   const std::string& device_address = query_result.device->GetAddress();
 
   // We can't know if a service is present or not until GATT service discovery
   // is complete for the device.
   if (query_result.device->IsGattServicesDiscoveryComplete()) {
     RemoteServerGetPrimaryServicesImpl(device_id, quantity, services_uuid,
                                        callback, query_result.device);
     return;
   }
 
-  VLOG(1) << "Services not yet discovered.";
+  DVLOG(1) << "Services not yet discovered.";
   pending_primary_services_requests_[device_address].push_back(base::Bind(
       &WebBluetoothServiceImpl::RemoteServerGetPrimaryServicesImpl,
       base::Unretained(this), device_id, quantity, services_uuid, callback));
 }
 
 void WebBluetoothServiceImpl::RemoteServiceGetCharacteristics(
     const std::string& service_instance_id,
     blink::mojom::WebBluetoothGATTQueryQuantity quantity,
     const base::Optional<BluetoothUUID>& characteristics_uuid,
     const RemoteServiceGetCharacteristicsCallback& callback) {
@@ skipping 285 matching lines @@
     service_ptr->instance_id = service_instance_id;
     service_ptr->uuid = service->GetUUID().canonical_value();
     response_services.push_back(std::move(service_ptr));
 
     if (quantity == blink::mojom::WebBluetoothGATTQueryQuantity::SINGLE) {
       break;
     }
   }
 
   if (!response_services.empty()) {
-    VLOG(1) << "Services found in device.";
+    DVLOG(1) << "Services found in device.";
     RecordGetPrimaryServicesOutcome(quantity,
                                     UMAGetPrimaryServiceOutcome::SUCCESS);
     callback.Run(blink::mojom::WebBluetoothResult::SUCCESS,
                  std::move(response_services));
     return;
   }
 
-  VLOG(1) << "Services not found in device.";
+  DVLOG(1) << "Services not found in device.";
   RecordGetPrimaryServicesOutcome(
       quantity, services_uuid ? UMAGetPrimaryServiceOutcome::NOT_FOUND
                               : UMAGetPrimaryServiceOutcome::NO_SERVICES);
   callback.Run(services_uuid
                    ? blink::mojom::WebBluetoothResult::SERVICE_NOT_FOUND
                    : blink::mojom::WebBluetoothResult::NO_SERVICES_FOUND,
                base::nullopt /* services */);
 }
 
 void WebBluetoothServiceImpl::OnGetDeviceSuccess(
     const RequestDeviceCallback& callback,
     blink::mojom::WebBluetoothRequestDeviceOptionsPtr options,
     const std::string& device_address) {
   device_chooser_controller_.reset();
 
   const device::BluetoothDevice* const device =
       GetAdapter()->GetDevice(device_address);
   if (device == nullptr) {
-    VLOG(1) << "Device " << device_address << " no longer in adapter";
+    DVLOG(1) << "Device " << device_address << " no longer in adapter";
     RecordRequestDeviceOutcome(UMARequestDeviceOutcome::CHOSEN_DEVICE_VANISHED);
     callback.Run(blink::mojom::WebBluetoothResult::CHOSEN_DEVICE_VANISHED,
                  nullptr /* device */);
     return;
   }
 
   const WebBluetoothDeviceId device_id_for_origin =
       allowed_devices_map_.AddDevice(GetOrigin(), device_address, options);
 
-  VLOG(1) << "Device: " << device->GetNameForDisplay();
+  DVLOG(1) << "Device: " << device->GetNameForDisplay();
 
   blink::mojom::WebBluetoothDevicePtr device_ptr =
       blink::mojom::WebBluetoothDevice::New();
   device_ptr->id = device_id_for_origin;
   device_ptr->name = device->GetName();
 
   RecordRequestDeviceOutcome(UMARequestDeviceOutcome::SUCCESS);
   callback.Run(blink::mojom::WebBluetoothResult::SUCCESS,
                std::move(device_ptr));
 }
@@ skipping 195 matching lines @@
   characteristic_id_to_service_id_.clear();
   service_id_to_device_address_.clear();
   connected_devices_.reset(
       new FrameConnectedBluetoothDevices(render_frame_host_));
   allowed_devices_map_ = BluetoothAllowedDevicesMap();
   device_chooser_controller_.reset();
   BluetoothAdapterFactoryWrapper::Get().ReleaseAdapter(this);
 }
 
 }  // namespace content