work in progress 2

content/browser/bluetooth/bluetooth_device_chooser_controller.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.
 
 #include "content/browser/bluetooth/bluetooth_device_chooser_controller.h"
 
 #include <set>
 #include <string>
 #include <unordered_set>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/memory/ptr_util.h"
 #include "base/metrics/histogram_macros.h"
 #include "base/strings/string_util.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "content/browser/bluetooth/bluetooth_blocklist.h"
 #include "content/browser/bluetooth/bluetooth_metrics.h"
 #include "content/browser/bluetooth/web_bluetooth_service_impl.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/content_browser_client.h"
 #include "content/public/browser/render_frame_host.h"
 #include "content/public/browser/web_contents.h"
 #include "content/public/browser/web_contents_delegate.h"
 #include "device/bluetooth/bluetooth_adapter.h"
 #include "device/bluetooth/bluetooth_common.h"
 #include "device/bluetooth/bluetooth_discovery_session.h"
 
+#include "base/logging.h"
+
 using device::BluetoothUUID;
 using UUIDSet = device::BluetoothDevice::UUIDSet;
 
 namespace {
 
 // Signal Strength Display Notes:
 //
 // RSSI values are displayed by the chooser to empower a user to differentiate
 // between multiple devices with the same name, comparing devices with different
 // names is a secondary goal. It is important that a user is able to move closer
@@ skipping 242 matching lines @@
           // TODO(jyasskin): Add a way for tests to control the dialog
           // directly, and change this to a reasonable discovery timeout.
           base::TimeDelta::FromSeconds(
               use_test_scan_duration_ ? kTestScanDuration : kScanDuration),
           base::Bind(&BluetoothDeviceChooserController::StopDeviceDiscovery,
                      // base::Timer guarantees it won't call back after its
                      // destructor starts.
                      base::Unretained(this)),
           /*is_repeating=*/false),
       weak_ptr_factory_(this) {
+  LOG(ERROR) << "[DJKim] BluetoothDeviceChooserController::BluetoothDeviceChooserController";
   CHECK(adapter_);
 }
 
 BluetoothDeviceChooserController::~BluetoothDeviceChooserController() {
   if (scanning_start_time_) {
     RecordScanningDuration(base::TimeTicks::Now() -
                            scanning_start_time_.value());
   }
 
   if (chooser_) {
     DCHECK(!error_callback_.is_null());
     error_callback_.Run(blink::mojom::WebBluetoothResult::CHOOSER_CANCELLED);
   }
 }
 
 void BluetoothDeviceChooserController::GetDevice(
     blink::mojom::WebBluetoothRequestDeviceOptionsPtr options,
     const SuccessCallback& success_callback,
     const ErrorCallback& error_callback) {
+  LOG(ERROR) << "[DJKim] BluetoothDeviceChooserController::GetDevice";
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
 
   // GetDevice should only be called once.
   DCHECK(success_callback_.is_null());
   DCHECK(error_callback_.is_null());
 
   success_callback_ = success_callback;
   error_callback_ = error_callback;
 
   // The renderer should never send invalid options.
@@ skipping 138 matching lines @@
       OnBluetoothChooserEvent(BluetoothChooser::Event::RESCAN,
                               "" /* device_address */);
     }
   }
 
   if (!powered) {
     discovery_session_timer_.Stop();
   }
 }
 
+void BluetoothDeviceChooserController::AdapterDiscoveringChanged(
+    bool discovering) {
+  LOG(ERROR) << "[DJKim] BluetoothDeviceChooserController::AdapterDiscoveringChanged";
+  if (!discovering && IsDiscoverySessionActive())
+   StopDeviceDiscovery();
+}
+
 int BluetoothDeviceChooserController::CalculateSignalStrengthLevel(
     int8_t rssi) {
   RecordRSSISignalStrength(rssi);
 
   if (rssi < k20thPercentileRSSI) {
     RecordRSSISignalStrengthLevel(content::UMARSSISignalStrengthLevel::LEVEL_0);
     return 0;
   } else if (rssi < k40thPercentileRSSI) {
     RecordRSSISignalStrengthLevel(content::UMARSSISignalStrengthLevel::LEVEL_1);
     return 1;
@@ skipping 15 matching lines @@
 
 void BluetoothDeviceChooserController::PopulateConnectedDevices() {
   for (const device::BluetoothDevice* device : adapter_->GetDevices()) {
     if (device->IsGattConnected()) {
       AddFilteredDevice(*device);
     }
   }
 }
 
 void BluetoothDeviceChooserController::StartDeviceDiscovery() {
+  LOG(ERROR) << "[DJKim] BluetoothDeviceChooserController::StartDeviceDiscovery >> start";
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
 
-  if (discovery_session_.get() && discovery_session_->IsActive()) {
+  LOG(ERROR) << "[DJKim] BluetoothDeviceChooserController::StartDeviceDiscovery >> #1";
+  if (IsDiscoverySessionActive()) {
     // Already running; just increase the timeout.
     discovery_session_timer_.Reset();
     return;
   }
 
+  LOG(ERROR) << "[DJKim] BluetoothDeviceChooserController::StartDeviceDiscovery >> #2";
   scanning_start_time_ = base::TimeTicks::Now();
 
-  chooser_->ShowDiscoveryState(BluetoothChooser::DiscoveryState::DISCOVERING);
+  LOG(ERROR) << "[DJKim] BluetoothDeviceChooserController::StartDeviceDiscovery >> #2-1";
+  if (chooser_)
+    chooser_->ShowDiscoveryState(BluetoothChooser::DiscoveryState::DISCOVERING);
+  else
+    LOG(ERROR) << "[DJKim] BluetoothDeviceChooserController::StartDeviceDiscovery >> #2-2";
+
+  LOG(ERROR) << "[DJKim] BluetoothDeviceChooserController::StartDeviceDiscovery >> #3";
+
+  if (adapter_) {
+    if (!options_) {
+      LOG(ERROR) << "[DJKim] BluetoothDeviceChooserController::StartDeviceDiscovery >> #3-1 return";
+      return;
+    }
+
   adapter_->StartDiscoverySessionWithFilter(
       ComputeScanFilter(options_->filters),
       base::Bind(
           &BluetoothDeviceChooserController::OnStartDiscoverySessionSuccess,
           weak_ptr_factory_.GetWeakPtr()),
       base::Bind(
           &BluetoothDeviceChooserController::OnStartDiscoverySessionFailed,
           weak_ptr_factory_.GetWeakPtr()));
+    }
+
+  LOG(ERROR) << "[DJKim] BluetoothDeviceChooserController::StartDeviceDiscovery >> end";
 }
 
 void BluetoothDeviceChooserController::StopDeviceDiscovery() {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
 
   if (scanning_start_time_) {
     RecordScanningDuration(base::TimeTicks::Now() -
                            scanning_start_time_.value());
     scanning_start_time_.reset();
   }
@@ skipping 85 matching lines @@
 }
 
 void BluetoothDeviceChooserController::PostErrorCallback(
     blink::mojom::WebBluetoothResult error) {
   if (!base::ThreadTaskRunnerHandle::Get()->PostTask(
           FROM_HERE, base::Bind(error_callback_, error))) {
     LOG(WARNING) << "No TaskRunner.";
   }
 }
 
+bool BluetoothDeviceChooserController::IsDiscoverySessionActive() {
+  if (discovery_session_ && discovery_session_->IsActive())
+    return true;
+
+  return false;
+}
+
+void BluetoothDeviceChooserController::StartDeviceDiscoveryForTesting() {
+  LOG(ERROR) << "[DJKim] BluetoothDeviceChooserController::StartDeviceDiscoveryForTesting";
+  StartDeviceDiscovery();
+}
+
 }  // namespace content