[DevTools] A setting for TCP discovery enablement

chrome/browser/devtools/device/devtools_android_bridge_browsertest.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 <algorithm>
+#include <array>
+
 #include "base/values.h"
 #include "chrome/browser/devtools/device/devtools_android_bridge.h"
 #include "chrome/browser/devtools/device/tcp_device_provider.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/ui/browser.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/common/pref_names.h"
 #include "chrome/test/base/in_process_browser_test.h"
 #include "chrome/test/base/ui_test_utils.h"
 #include "components/prefs/pref_service.h"
 
 class DevToolsAndroidBridgeTest : public InProcessBrowserTest {
 };
 
+template<int i, class ... values>
+struct tuple_ops {
+  static void fill_array(std::array<std::string, sizeof...(values)>& array,
+                         const std::tuple<values...>& tuple) {
+    array[i] = std::get<i>(tuple);
+    tuple_ops<i - 1, values...>::fill_array(array, tuple);
+  }
+};
+
+template<class ... values>
+struct tuple_ops<0, values ...> {
+  static void fill_array(std::array<std::string, sizeof...(values)>& array,
+                         const std::tuple<values...>& tuple) {
+    array[0] = std::get<0>(tuple);
+  }
+};
+
+template<class ... values>
+std::array<std::string, sizeof...(values)> array_from_tuple(

[dgozman, 2016/08/26 23:31:43]

Let's use std::vector<>, and push items there manually.

[eostroukhov, 2016/08/29 22:06:31]

I made if even more boring then you suggested...

+    const std::tuple<values...> tuple) {
+  auto result = std::array<std::string, sizeof...(values)>();
+  tuple_ops<sizeof...(values) - 1, values...>::fill_array(result, tuple);
+  return result;
+}
+
 static void assign_from_callback(scoped_refptr<TCPDeviceProvider>* store,
                                  int* invocation_counter,
                                  scoped_refptr<TCPDeviceProvider> value) {
   (*invocation_counter)++;
   *store = value;
 }
 
-IN_PROC_BROWSER_TEST_F(DevToolsAndroidBridgeTest, UpdatesTargetDiscovery) {
+template<class ... Strings>
+bool expect_all_tcp_targets(const std::tuple<Strings ...>& expected,

[dgozman, 2016/08/26 23:31:43]

Can we just sort two arrays and compare?

[eostroukhov, 2016/08/29 22:06:31]

Acknowledged.

+                        scoped_refptr<TCPDeviceProvider> provider) {
+  auto array = array_from_tuple(expected);
+  int mask = 0;
+  bool success = true;
+  for (const net::HostPortPair hostport : provider->get_targets_for_test()) {
+    std::string value = hostport.ToString();
+    auto iter = std::find(array.begin(), array.end(), value);
+    if (iter == array.end()) {
+      fprintf(stderr, "[%s] Unexpected: %s\n", __FUNCTION__, value.c_str());

[dgozman, 2016/08/26 23:31:43]

EXPECT_EQ(vector1, vector2) << "Actual targets: " << vector2

[eostroukhov, 2016/08/29 22:06:31]

Acknowledged.

+      success = false;
+    } else {
+      mask |= 1 << (iter - array.begin());
+    }
+  }
+  int all_bits_set = (1 << array.size()) - 1;
+  if (mask == all_bits_set)
+    return success;
+
+  std::string missing;
+  for (size_t i = 0; i < array.size(); i++) {
+    if (!(mask & (1 << i))) {
+      if (!missing.empty())
+        missing += ", ";
+      missing += array[i];
+    }
+  }
+  fprintf(stderr, "[%s] Missing: %s\n", __FUNCTION__, missing.c_str());
+  return false;
+}
+
+IN_PROC_BROWSER_TEST_F(DevToolsAndroidBridgeTest, DiscoveryListChanges) {
   Profile* profile = browser()->profile();
 
   PrefService* service = profile->GetPrefs();
-  service->ClearPref(prefs::kDevToolsTargetDiscoveryConfig);
+  service->ClearPref(prefs::kDevToolsTCPDiscoveryConfig);
+  service->SetBoolean(prefs::kDevToolsTCPDiscoveryEnabled, true);
 
   DevToolsAndroidBridge* bridge =
       DevToolsAndroidBridge::Factory::GetForProfile(profile);
 
   scoped_refptr<TCPDeviceProvider> provider;
   int called = 0;
   bridge->set_tcp_provider_callback_for_test(
       base::Bind(assign_from_callback, &provider, &called));
 
   EXPECT_LT(0, called);
-  EXPECT_EQ(nullptr, provider);
+  EXPECT_NE(nullptr, provider);
+
+  EXPECT_TRUE(expect_all_tcp_targets(
+      std::make_tuple("localhost:9222", "localhost:9229"), provider));
 
   int invocations = called;
   base::ListValue list;
   list.AppendString("somehost:2000");
 
-  service->Set(prefs::kDevToolsTargetDiscoveryConfig, list);
+  service->Set(prefs::kDevToolsTCPDiscoveryConfig, list);
 
   EXPECT_LT(invocations, called);
   EXPECT_NE(nullptr, provider);
-  std::set<net::HostPortPair> pairs = provider->get_targets_for_test();
-  EXPECT_EQ(1UL, pairs.size());
-  net::HostPortPair pair = *pairs.begin();
-  EXPECT_EQ(2000, pair.port());
-  EXPECT_EQ("somehost", pair.HostForURL());
+  EXPECT_TRUE(expect_all_tcp_targets(
+      std::make_tuple("somehost:2000"), provider));
 
   invocations = called;
   list.Clear();
-  service->Set(prefs::kDevToolsTargetDiscoveryConfig, list);
+  service->Set(prefs::kDevToolsTCPDiscoveryConfig, list);
 
   EXPECT_LT(invocations, called);
   EXPECT_EQ(nullptr, provider);
   invocations = called;
 
   list.AppendString("b:1");
   list.AppendString("c:2");
   list.AppendString("<not really a good address.");
   list.AppendString("d:3");
   list.AppendString("c:2");
-  service->Set(prefs::kDevToolsTargetDiscoveryConfig, list);
+  service->Set(prefs::kDevToolsTCPDiscoveryConfig, list);
 
   EXPECT_LT(invocations, called);
   EXPECT_NE(nullptr, provider);
-  pairs = provider->get_targets_for_test();
-  EXPECT_EQ(3UL, pairs.size());
-  for (const net::HostPortPair pair : pairs) {
-    EXPECT_EQ(pair.port(), pair.HostForURL()[0] - 'a');
+  EXPECT_TRUE(expect_all_tcp_targets(
+      std::make_tuple("b:1", "c:2", "d:3"), provider));
+}
+
+
+IN_PROC_BROWSER_TEST_F(DevToolsAndroidBridgeTest, DefaultValues) {
+  Profile* profile = browser()->profile();
+
+  PrefService* service = profile->GetPrefs();
+  DevToolsAndroidBridge::Factory::GetForProfile(profile);
+  service->ClearPref(prefs::kDevToolsTCPDiscoveryEnabled);
+  service->ClearPref(prefs::kDevToolsTCPDiscoveryConfig);
+
+  const base::ListValue* targets =
+    service->GetList(prefs::kDevToolsTCPDiscoveryConfig);
+  EXPECT_NE(nullptr, targets);
+  EXPECT_EQ(2ul, targets->GetSize());
+
+  int matched_mask = 0;
+  std::array<std::string, 2> EXPECTED_TARGETS =
+      {{"localhost:9222", "localhost:9229"}};
+
+  for (size_t i = 0; i < targets->GetSize(); i++) {
+    std::string target;
+    EXPECT_TRUE(targets->GetString(i, &target));
+    for (size_t j = 0; j < EXPECTED_TARGETS.size(); j++) {
+      if (target == EXPECTED_TARGETS[j]) {
+        matched_mask |= 1 << j;
+      }
+    }
   }
+
+  EXPECT_FALSE(service->GetBoolean(prefs::kDevToolsTCPDiscoveryEnabled));
+
+  EXPECT_EQ(3, matched_mask);
 }
+
+
+IN_PROC_BROWSER_TEST_F(DevToolsAndroidBridgeTest, TCPEnableChange) {
+  Profile* profile = browser()->profile();
+
+  PrefService* service = profile->GetPrefs();
+  service->ClearPref(prefs::kDevToolsTCPDiscoveryConfig);
+  service->ClearPref(prefs::kDevToolsTCPDiscoveryEnabled);
+
+  DevToolsAndroidBridge* bridge =
+      DevToolsAndroidBridge::Factory::GetForProfile(profile);
+
+  scoped_refptr<TCPDeviceProvider> provider;
+  int called = 0;
+  bridge->set_tcp_provider_callback_for_test(
+      base::Bind(assign_from_callback, &provider, &called));
+
+  EXPECT_EQ(nullptr, provider);
+
+  service->SetBoolean(prefs::kDevToolsTCPDiscoveryEnabled, true);
+
+  EXPECT_NE(nullptr, provider);
+  EXPECT_TRUE(expect_all_tcp_targets(
+      std::make_tuple("localhost:9222", "localhost:9229"), provider));
+
+  service->SetBoolean(prefs::kDevToolsTCPDiscoveryEnabled, false);
+
+  EXPECT_EQ(nullptr, provider);
+}