From 720b10490523188c34b012d1ccf2059020cc13e1 Mon Sep 17 00:00:00 2001 From: "mukai@chromium.org" Date: Wed, 23 Jul 2014 08:48:40 +0000 Subject: Moves some functions in search.h to components. These functions are simplistic and doesn't depend on chrome's feature, so there's no reason to be under chrome/browser. Moving to components/ would help further componentization task of autocomplete anad omnibox_field_trials. BUG=371538 R=brettw@chromium.org, pkasting@chromium.org, blundell@chromium.org TBR=tedchoc@chromium.org, jhawkins@chromium.org TEST=build Review URL: https://codereview.chromium.org/393173002 git-svn-id: svn://svn.chromium.org/chrome/trunk/src@284885 0039d316-1c4b-4281-b951-d872f2087c98 --- components/search/BUILD.gn | 16 +++ components/search/DEPS | 3 + components/search/OWNERS | 4 + components/search/search.cc | 146 +++++++++++++++++++++++++++ components/search/search.h | 59 +++++++++++ components/search/search_android_unittest.cc | 30 ++++++ components/search/search_switches.cc | 16 +++ components/search/search_switches.h | 18 ++++ components/search/search_unittest.cc | 133 ++++++++++++++++++++++++ 9 files changed, 425 insertions(+) create mode 100644 components/search/BUILD.gn create mode 100644 components/search/DEPS create mode 100644 components/search/OWNERS create mode 100644 components/search/search.cc create mode 100644 components/search/search.h create mode 100644 components/search/search_android_unittest.cc create mode 100644 components/search/search_switches.cc create mode 100644 components/search/search_switches.h create mode 100644 components/search/search_unittest.cc (limited to 'components/search') diff --git a/components/search/BUILD.gn b/components/search/BUILD.gn new file mode 100644 index 0000000..a895701 --- /dev/null +++ b/components/search/BUILD.gn @@ -0,0 +1,16 @@ +# 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. + +static_library("search") { + sources = [ + "search.cc", + "search.h", + "search_switches.cc", + "search_switches.h", + ] + + deps = [ + "//base", + ] +} diff --git a/components/search/DEPS b/components/search/DEPS new file mode 100644 index 0000000..80f6f90 --- /dev/null +++ b/components/search/DEPS @@ -0,0 +1,3 @@ +include_rules = [ + "+components/variations", +] diff --git a/components/search/OWNERS b/components/search/OWNERS new file mode 100644 index 0000000..a7265f6 --- /dev/null +++ b/components/search/OWNERS @@ -0,0 +1,4 @@ +kmadhusu@chromium.org +brettw@chromium.org +jered@chromium.org +samarth@chromium.org diff --git a/components/search/search.cc b/components/search/search.cc new file mode 100644 index 0000000..8689e51 --- /dev/null +++ b/components/search/search.cc @@ -0,0 +1,146 @@ +// 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. + +#include "components/search/search.h" + +#include "base/command_line.h" +#include "base/metrics/field_trial.h" +#include "base/strings/string_number_conversions.h" +#include "base/strings/string_split.h" +#include "base/strings/string_util.h" +#include "base/strings/utf_string_conversions.h" +#include "components/search/search_switches.h" + +namespace chrome { + +namespace { + +// Configuration options for Embedded Search. +// EmbeddedSearch field trials are named in such a way that we can parse out +// the experiment configuration from the trial's group name in order to give +// us maximum flexability in running experiments. +// Field trial groups should be named things like "Group7 espv:2 instant:1". +// The first token is always GroupN for some integer N, followed by a +// space-delimited list of key:value pairs which correspond to these flags: +const char kEmbeddedPageVersionFlagName[] = "espv"; + +#if defined(OS_IOS) +const uint64 kEmbeddedPageVersionDefault = 1; +#elif defined(OS_ANDROID) +const uint64 kEmbeddedPageVersionDefault = 1; +// Use this variant to enable EmbeddedSearch SearchBox API in the results page. +const uint64 kEmbeddedSearchEnabledVersion = 2; +#else +const uint64 kEmbeddedPageVersionDefault = 2; +#endif + +// Constants for the field trial name and group prefix. +// Note in M30 and below this field trial was named "InstantExtended" and in +// M31 was renamed to EmbeddedSearch for clarity and cleanliness. Since we +// can't easilly sync up Finch configs with the pushing of this change to +// Dev & Canary, for now the code accepts both names. +// TODO(dcblack): Remove the InstantExtended name once M31 hits the Beta +// channel. +const char kInstantExtendedFieldTrialName[] = "InstantExtended"; +const char kEmbeddedSearchFieldTrialName[] = "EmbeddedSearch"; + +// If the field trial's group name ends with this string its configuration will +// be ignored and Instant Extended will not be enabled by default. +const char kDisablingSuffix[] = "DISABLED"; + +} // namespace + +bool IsInstantExtendedAPIEnabled() { +#if defined(OS_IOS) + return false; +#elif defined(OS_ANDROID) + return EmbeddedSearchPageVersion() == kEmbeddedSearchEnabledVersion; +#else + return true; +#endif // defined(OS_IOS) +} + +// Determine what embedded search page version to request from the user's +// default search provider. If 0, the embedded search UI should not be enabled. +uint64 EmbeddedSearchPageVersion() { +#if defined(OS_ANDROID) + if (CommandLine::ForCurrentProcess()->HasSwitch( + switches::kEnableEmbeddedSearchAPI)) { + return kEmbeddedSearchEnabledVersion; + } +#endif + + FieldTrialFlags flags; + if (GetFieldTrialInfo(&flags)) { + return GetUInt64ValueForFlagWithDefault(kEmbeddedPageVersionFlagName, + kEmbeddedPageVersionDefault, + flags); + } + return kEmbeddedPageVersionDefault; +} + +bool GetFieldTrialInfo(FieldTrialFlags* flags) { + // Get the group name. If the EmbeddedSearch trial doesn't exist, look for + // the older InstantExtended name. + std::string group_name = base::FieldTrialList::FindFullName( + kEmbeddedSearchFieldTrialName); + if (group_name.empty()) { + group_name = base::FieldTrialList::FindFullName( + kInstantExtendedFieldTrialName); + } + + if (EndsWith(group_name, kDisablingSuffix, true)) + return false; + + // We have a valid trial that isn't disabled. Extract the flags. + std::string group_prefix(group_name); + size_t first_space = group_name.find(" "); + if (first_space != std::string::npos) { + // There is a flags section of the group name. Split that out and parse it. + group_prefix = group_name.substr(0, first_space); + if (!base::SplitStringIntoKeyValuePairs(group_name.substr(first_space), + ':', ' ', flags)) { + // Failed to parse the flags section. Assume the whole group name is + // invalid. + return false; + } + } + return true; +} + +// Given a FieldTrialFlags object, returns the string value of the provided +// flag. +std::string GetStringValueForFlagWithDefault(const std::string& flag, + const std::string& default_value, + const FieldTrialFlags& flags) { + FieldTrialFlags::const_iterator i; + for (i = flags.begin(); i != flags.end(); i++) { + if (i->first == flag) + return i->second; + } + return default_value; +} + +// Given a FieldTrialFlags object, returns the uint64 value of the provided +// flag. +uint64 GetUInt64ValueForFlagWithDefault(const std::string& flag, + uint64 default_value, + const FieldTrialFlags& flags) { + uint64 value; + std::string str_value = + GetStringValueForFlagWithDefault(flag, std::string(), flags); + if (base::StringToUint64(str_value, &value)) + return value; + return default_value; +} + +// Given a FieldTrialFlags object, returns the boolean value of the provided +// flag. +bool GetBoolValueForFlagWithDefault(const std::string& flag, + bool default_value, + const FieldTrialFlags& flags) { + return !!GetUInt64ValueForFlagWithDefault(flag, default_value ? 1 : 0, flags); +} + +} // namespace chrome diff --git a/components/search/search.h b/components/search/search.h new file mode 100644 index 0000000..df27e60 --- /dev/null +++ b/components/search/search.h @@ -0,0 +1,59 @@ +// 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. + +#ifndef COMPONENTS_SEARCH_SEARCH_H_ +#define COMPONENTS_SEARCH_SEARCH_H_ + +#include +#include +#include + +#include "base/basictypes.h" +#include "base/strings/string16.h" + +namespace chrome { + +// Returns whether the Instant Extended API is enabled. +bool IsInstantExtendedAPIEnabled(); + +// Returns the value to pass to the &espv CGI parameter when loading the +// embedded search page from the user's default search provider. Returns 0 if +// the Instant Extended API is not enabled. +uint64 EmbeddedSearchPageVersion(); + +// Type for a collection of experiment configuration parameters. +typedef std::vector > FieldTrialFlags; + +// Finds the active field trial group name and parses out the configuration +// flags. On success, |flags| will be filled with the field trial flags. |flags| +// must not be NULL. Returns true iff the active field trial is successfully +// parsed and not disabled. +// Note that |flags| may be successfully populated in some cases when false is +// returned - in these cases it should not be used. +// Exposed for testing only. +bool GetFieldTrialInfo(FieldTrialFlags* flags); + +// Given a FieldTrialFlags object, returns the string value of the provided +// flag. +// Exposed for testing only. +std::string GetStringValueForFlagWithDefault(const std::string& flag, + const std::string& default_value, + const FieldTrialFlags& flags); + +// Given a FieldTrialFlags object, returns the uint64 value of the provided +// flag. +// Exposed for testing only. +uint64 GetUInt64ValueForFlagWithDefault(const std::string& flag, + uint64 default_value, + const FieldTrialFlags& flags); + +// Given a FieldTrialFlags object, returns the bool value of the provided flag. +// Exposed for testing only. +bool GetBoolValueForFlagWithDefault(const std::string& flag, + bool default_value, + const FieldTrialFlags& flags); + +} // namespace chrome + +#endif // COMPONENTS_SEARCH_SEARCH_H_ diff --git a/components/search/search_android_unittest.cc b/components/search/search_android_unittest.cc new file mode 100644 index 0000000..9c67edff --- /dev/null +++ b/components/search/search_android_unittest.cc @@ -0,0 +1,30 @@ +// 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. + +#include "components/search/search.h" + +#include "base/command_line.h" +#include "base/memory/scoped_ptr.h" +#include "base/metrics/field_trial.h" +#include "base/metrics/statistics_recorder.h" +#include "components/search/search_switches.h" +#include "components/variations/entropy_provider.h" +#include "testing/gtest/include/gtest/gtest.h" + +namespace chrome { + +namespace { + +TEST(SearchTest, EmbeddedSearchAPIEnabled) { + EXPECT_EQ(1ul, EmbeddedSearchPageVersion()); + EXPECT_FALSE(IsInstantExtendedAPIEnabled()); + CommandLine::ForCurrentProcess()->AppendSwitch( + switches::kEnableEmbeddedSearchAPI); + EXPECT_EQ(2ul, EmbeddedSearchPageVersion()); + EXPECT_TRUE(IsInstantExtendedAPIEnabled()); +} + +} // namespace + +} // namespace chrome diff --git a/components/search/search_switches.cc b/components/search/search_switches.cc new file mode 100644 index 0000000..9359725 --- /dev/null +++ b/components/search/search_switches.cc @@ -0,0 +1,16 @@ +// 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. + +#include "components/search/search_switches.h" + +namespace switches { + +#if defined(OS_ANDROID) + +// Enables EmbeddedSearch API in the search results page. +const char kEnableEmbeddedSearchAPI[] = "enable-embeddedsearch-api"; + +#endif + +} // namespace switches diff --git a/components/search/search_switches.h b/components/search/search_switches.h new file mode 100644 index 0000000..48b50c1 --- /dev/null +++ b/components/search/search_switches.h @@ -0,0 +1,18 @@ +// 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. + +#ifndef COMPONENTS_SEARCH_SEARCH_SWITCHES_H_ +#define COMPONENTS_SEARCH_SEARCH_SWITCHES_H_ + +#include "build/build_config.h" + +namespace switches { + +#if defined(OS_ANDROID) +extern const char kEnableEmbeddedSearchAPI[]; +#endif + +} // namespace switches + +#endif // COMPONENTS_SEARCH_SEARCH_SWITCHES_H_ diff --git a/components/search/search_unittest.cc b/components/search/search_unittest.cc new file mode 100644 index 0000000..b8c4e1d --- /dev/null +++ b/components/search/search_unittest.cc @@ -0,0 +1,133 @@ +// 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. + +#include "components/search/search.h" + +#include "base/metrics/field_trial.h" +#include "base/metrics/statistics_recorder.h" +#include "components/variations/entropy_provider.h" +#include "testing/gtest/include/gtest/gtest.h" + +namespace chrome { + +class EmbeddedSearchFieldTrialTest : public testing::Test { + protected: + virtual void SetUp() { + field_trial_list_.reset(new base::FieldTrialList( + new metrics::SHA1EntropyProvider("42"))); + base::StatisticsRecorder::Initialize(); + } + + private: + scoped_ptr field_trial_list_; +}; + +TEST_F(EmbeddedSearchFieldTrialTest, GetFieldTrialInfoEmptyAndValid) { + FieldTrialFlags flags; + + EXPECT_TRUE(GetFieldTrialInfo(&flags)); + EXPECT_EQ(0ul, flags.size()); + + ASSERT_TRUE(base::FieldTrialList::CreateFieldTrial("EmbeddedSearch", + "Group77")); + EXPECT_TRUE(GetFieldTrialInfo(&flags)); + EXPECT_EQ(0ul, flags.size()); +} + +TEST_F(EmbeddedSearchFieldTrialTest, GetFieldTrialInfoInvalidNumber) { + FieldTrialFlags flags; + + ASSERT_TRUE(base::FieldTrialList::CreateFieldTrial("EmbeddedSearch", + "Group77.2")); + EXPECT_TRUE(GetFieldTrialInfo(&flags)); + EXPECT_EQ(0ul, flags.size()); +} + +TEST_F(EmbeddedSearchFieldTrialTest, GetFieldTrialInfoInvalidName) { + FieldTrialFlags flags; + + ASSERT_TRUE(base::FieldTrialList::CreateFieldTrial("EmbeddedSearch", + "Invalid77")); + EXPECT_TRUE(GetFieldTrialInfo(&flags)); + EXPECT_EQ(0ul, flags.size()); +} + +TEST_F(EmbeddedSearchFieldTrialTest, GetFieldTrialInfoValidGroup) { + FieldTrialFlags flags; + + ASSERT_TRUE(base::FieldTrialList::CreateFieldTrial("EmbeddedSearch", + "Group77")); + EXPECT_TRUE(GetFieldTrialInfo(&flags)); + EXPECT_EQ(0ul, flags.size()); +} + +TEST_F(EmbeddedSearchFieldTrialTest, GetFieldTrialInfoValidFlag) { + FieldTrialFlags flags; + + EXPECT_EQ(9999ul, GetUInt64ValueForFlagWithDefault("foo", 9999, flags)); + ASSERT_TRUE(base::FieldTrialList::CreateFieldTrial("EmbeddedSearch", + "Group77 foo:6")); + EXPECT_TRUE(GetFieldTrialInfo(&flags)); + EXPECT_EQ(1ul, flags.size()); + EXPECT_EQ(6ul, GetUInt64ValueForFlagWithDefault("foo", 9999, flags)); +} + +TEST_F(EmbeddedSearchFieldTrialTest, GetFieldTrialInfoNewName) { + FieldTrialFlags flags; + + EXPECT_EQ(9999ul, GetUInt64ValueForFlagWithDefault("foo", 9999, flags)); + ASSERT_TRUE(base::FieldTrialList::CreateFieldTrial("EmbeddedSearch", + "Group77 foo:6")); + EXPECT_TRUE(GetFieldTrialInfo(&flags)); + EXPECT_EQ(1ul, flags.size()); + EXPECT_EQ(6ul, GetUInt64ValueForFlagWithDefault("foo", 9999, flags)); +} + +TEST_F(EmbeddedSearchFieldTrialTest, GetFieldTrialInfoNewNameOverridesOld) { + FieldTrialFlags flags; + + EXPECT_EQ(9999ul, GetUInt64ValueForFlagWithDefault("foo", 9999, flags)); + ASSERT_TRUE(base::FieldTrialList::CreateFieldTrial("EmbeddedSearch", + "Group77 foo:6")); + ASSERT_TRUE(base::FieldTrialList::CreateFieldTrial("InstantExtended", + "Group78 foo:5")); + EXPECT_TRUE(GetFieldTrialInfo(&flags)); + EXPECT_EQ(1ul, flags.size()); + EXPECT_EQ(6ul, GetUInt64ValueForFlagWithDefault("foo", 9999, flags)); +} + +TEST_F(EmbeddedSearchFieldTrialTest, GetFieldTrialInfoLotsOfFlags) { + FieldTrialFlags flags; + + ASSERT_TRUE(base::FieldTrialList::CreateFieldTrial( + "EmbeddedSearch", "Group77 bar:1 baz:7 cat:dogs")); + EXPECT_TRUE(GetFieldTrialInfo(&flags)); + EXPECT_EQ(3ul, flags.size()); + EXPECT_EQ(true, GetBoolValueForFlagWithDefault("bar", false, flags)); + EXPECT_EQ(7ul, GetUInt64ValueForFlagWithDefault("baz", 0, flags)); + EXPECT_EQ("dogs", + GetStringValueForFlagWithDefault("cat", std::string(), flags)); + EXPECT_EQ("default", + GetStringValueForFlagWithDefault("moose", "default", flags)); +} + +TEST_F(EmbeddedSearchFieldTrialTest, GetFieldTrialInfoDisabled) { + FieldTrialFlags flags; + + ASSERT_TRUE(base::FieldTrialList::CreateFieldTrial( + "EmbeddedSearch", "Group77 bar:1 baz:7 cat:dogs DISABLED")); + EXPECT_FALSE(GetFieldTrialInfo(&flags)); + EXPECT_EQ(0ul, flags.size()); +} + +TEST_F(EmbeddedSearchFieldTrialTest, GetFieldTrialInfoControlFlags) { + FieldTrialFlags flags; + + ASSERT_TRUE(base::FieldTrialList::CreateFieldTrial( + "EmbeddedSearch", "Control77 bar:1 baz:7 cat:dogs")); + EXPECT_TRUE(GetFieldTrialInfo(&flags)); + EXPECT_EQ(3ul, flags.size()); +} + +} // namespace chrome -- cgit v1.1