1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
|
// Copyright 2012 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 CHROME_BROWSER_SEARCH_SEARCH_H_
#define CHROME_BROWSER_SEARCH_SEARCH_H_
#include <string>
#include <utility>
#include <vector>
#include "base/basictypes.h"
#include "base/strings/string16.h"
class GURL;
class Profile;
class TemplateURL;
class TemplateURLRef;
namespace content {
class NavigationEntry;
class WebContents;
}
namespace user_prefs {
class PrefRegistrySyncable;
}
namespace chrome {
enum OptInState {
// The user has not manually opted in/out of InstantExtended.
INSTANT_EXTENDED_NOT_SET,
// The user has opted-in to InstantExtended.
INSTANT_EXTENDED_OPT_IN,
// The user has opted-out of InstantExtended.
INSTANT_EXTENDED_OPT_OUT,
INSTANT_EXTENDED_OPT_IN_STATE_ENUM_COUNT,
};
// Use this value for "start margin" to prevent the "es_sm" parameter from
// being used.
extern const int kDisableStartMargin;
// 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();
// Returns whether query extraction is enabled.
bool IsQueryExtractionEnabled();
// Extracts and returns search terms from |url|. Returns empty string if the URL
// is not secure or doesn't have a search term replacement key. Does not
// consider IsQueryExtractionEnabled() and does not check for a privileged
// process, so most callers should use GetSearchTerms() below instead.
string16 GetSearchTermsFromURL(Profile* profile, const GURL& url);
// Returns the search terms attached to a specific NavigationEntry, or empty
// string otherwise. Does not consider IsQueryExtractionEnabled(), so most
// callers should use GetSearchTerms() below instead.
string16 GetSearchTermsFromNavigationEntry(
const content::NavigationEntry* entry);
// Returns search terms if this WebContents is a search results page. It looks
// in the visible NavigationEntry first, to see if search terms have already
// been extracted. Failing that, it tries to extract search terms from the URL.
// Returns a blank string if search terms were not found, or if search terms
// extraction is disabled for this WebContents or profile.
string16 GetSearchTerms(const content::WebContents* contents);
// Returns true if |url| should be rendered in the Instant renderer process.
bool ShouldAssignURLToInstantRenderer(const GURL& url, Profile* profile);
// Returns true if the visible entry of |contents| is a New Tab Page rendered
// by Instant. A page that matches the search or Instant URL of the default
// search provider but does not have any search terms is considered an Instant
// New Tab Page.
bool IsInstantNTP(const content::WebContents* contents);
// Same as IsInstantNTP but uses |nav_entry| to determine the URL for the page
// instead of using the visible entry.
bool NavEntryIsInstantNTP(const content::WebContents* contents,
const content::NavigationEntry* nav_entry);
// Returns the Instant URL of the default search engine. Returns an empty GURL
// if the engine doesn't have an Instant URL, or if it shouldn't be used (say
// because it doesn't satisfy the requirements for extended mode or if Instant
// is disabled through preferences). Callers must check that the returned URL is
// valid before using it. The value of |start_margin| is used for the "es_sm"
// parameter in the URL.
// NOTE: This method expands the default search engine's instant_url template,
// so it shouldn't be called from SearchTermsData or other such code that would
// lead to an infinite recursion.
GURL GetInstantURL(Profile* profile, int start_margin);
// Returns the Local Instant URL of the New Tab Page.
// TODO(kmadhusu): Remove this function and update the call sites.
GURL GetLocalInstantURL(Profile* profile);
// Returns true if 'use_remote_ntp_on_startup' flag is enabled in field trials
// to always show the remote NTP on browser startup.
bool ShouldPreferRemoteNTPOnStartup();
// Returns true if the Instant NTP should be preloaded before it is shown.
bool ShouldPreloadInstantNTP(Profile* profile);
// Returns true if the Instant NTP should be shown and false if not.
bool ShouldShowInstantNTP();
// Returns true if the recent tabs link should be shown on the local NTP in
// field trials.
bool ShouldShowRecentTabsOnNTP();
// Returns true if |my_url| matches |other_url|.
bool MatchesOriginAndPath(const GURL& my_url, const GURL& other_url);
// Transforms the input |url| into its "privileged URL". The returned URL
// facilitates grouping process-per-site. The |url| is transformed, for
// example, from
//
// https://www.google.com/search?espv=1&q=tractors
//
// to the privileged URL
//
// chrome-search://www.google.com/search?espv=1&q=tractors
//
// Notice the scheme change.
//
// If the input is already a privileged URL then that same URL is returned.
GURL GetPrivilegedURLForInstant(const GURL& url, Profile* profile);
// Returns true if the input |url| is a privileged Instant URL.
bool IsPrivilegedURLForInstant(const GURL& url);
// Returns the staleness timeout (in seconds) that should be used to refresh the
// InstantLoader.
int GetInstantLoaderStalenessTimeoutSec();
// Returns true if |contents| corresponds to a preloaded instant extended NTP.
bool IsPreloadedInstantExtendedNTP(const content::WebContents* contents);
// -----------------------------------------------------
// The following APIs are exposed for use in tests only.
// -----------------------------------------------------
// Forces the Instant Extended API to be enabled for tests.
void EnableInstantExtendedAPIForTesting();
// Forces the Instant Extended API to be disabled for tests.
void DisableInstantExtendedAPIForTesting();
// Type for a collection of experiment configuration parameters.
typedef std::vector<std::pair<std::string, std::string> > FieldTrialFlags;
// Given a field trial group name, parses out the group number and configuration
// flags. On success, |flags| will be filled with the field trial flags. |flags|
// must not be NULL. If not NULL, |group_number| will receive the experiment
// group number.
// Returns true iff field trial info was successfully parsed out of
// |group_name|.
// Exposed for testing only.
bool GetFieldTrialInfo(const std::string& group_name,
FieldTrialFlags* flags,
uint64* group_number);
// 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);
// Let tests reset the gate that prevents metrics from being sent more than
// once.
void ResetInstantExtendedOptInStateGateForTest();
} // namespace chrome
#endif // CHROME_BROWSER_SEARCH_SEARCH_H_
|
