OLD | NEW |
| (Empty) |
1 // Copyright (c) 2011 The Chromium Authors. All rights reserved. | |
2 // Use of this source code is governed by a BSD-style license that can be | |
3 // found in the LICENSE file. | |
4 | |
5 #include "chrome/browser/extensions/extension_rlz_module.h" | |
6 | |
7 #include "base/memory/scoped_ptr.h" | |
8 #include "base/threading/thread_restrictions.h" | |
9 #include "base/values.h" | |
10 #include "chrome/common/extensions/extension.h" | |
11 #include "rlz/win/lib/lib_values.h" | |
12 | |
13 namespace { | |
14 | |
15 bool GetProductFromName(const std::string& product_name, | |
16 rlz_lib::Product* product) { | |
17 bool success = true; | |
18 switch (product_name[0]) { | |
19 case 'B': | |
20 *product = rlz_lib::FF_TOOLBAR; | |
21 break; | |
22 case 'C': | |
23 *product = rlz_lib::CHROME; | |
24 break; | |
25 case 'D': | |
26 *product = rlz_lib::DESKTOP; | |
27 break; | |
28 case 'K': | |
29 *product = rlz_lib::QSB_WIN; | |
30 break; | |
31 case 'N': | |
32 *product = rlz_lib::PINYIN_IME; | |
33 break; | |
34 case 'P': | |
35 *product = rlz_lib::TOOLBAR_NOTIFIER; | |
36 break; | |
37 case 'T': | |
38 *product = rlz_lib::IE_TOOLBAR; | |
39 break; | |
40 case 'U': | |
41 *product = rlz_lib::PACK; | |
42 break; | |
43 case 'W': | |
44 *product = rlz_lib::WEBAPPS; | |
45 break; | |
46 default: | |
47 success = false; | |
48 break; | |
49 } | |
50 | |
51 return success; | |
52 } | |
53 | |
54 bool GetEventFromName(const std::string& event_name, | |
55 rlz_lib::Event* event_id) { | |
56 *event_id = rlz_lib::INVALID_EVENT; | |
57 | |
58 if (event_name == "install") { | |
59 *event_id = rlz_lib::INSTALL; | |
60 } else if (event_name == "set-to-google") { | |
61 *event_id = rlz_lib::SET_TO_GOOGLE; | |
62 } else if (event_name == "first-search") { | |
63 *event_id = rlz_lib::FIRST_SEARCH; | |
64 } else if (event_name == "activate") { | |
65 *event_id = rlz_lib::ACTIVATE; | |
66 } | |
67 | |
68 return *event_id != rlz_lib::INVALID_EVENT; | |
69 } | |
70 | |
71 } // namespace | |
72 | |
73 bool RlzRecordProductEventFunction::RunImpl() { | |
74 // This can be slow if registry access goes to disk. Should preferably | |
75 // perform registry operations on the File thread. | |
76 // http://code.google.com/p/chromium/issues/detail?id=62098 | |
77 base::ThreadRestrictions::ScopedAllowIO allow_io; | |
78 | |
79 std::string product_name; | |
80 EXTENSION_FUNCTION_VALIDATE(args_->GetString(0, &product_name)); | |
81 rlz_lib::Product product; | |
82 EXTENSION_FUNCTION_VALIDATE(GetProductFromName(product_name, &product)); | |
83 | |
84 std::string ap_name; | |
85 EXTENSION_FUNCTION_VALIDATE(args_->GetString(1, &ap_name)); | |
86 rlz_lib::AccessPoint access_point; | |
87 EXTENSION_FUNCTION_VALIDATE(rlz_lib::GetAccessPointFromName(ap_name.c_str(), | |
88 &access_point)); | |
89 | |
90 std::string event_name; | |
91 EXTENSION_FUNCTION_VALIDATE(args_->GetString(2, &event_name)); | |
92 rlz_lib::Event event_id; | |
93 EXTENSION_FUNCTION_VALIDATE(GetEventFromName(event_name, &event_id)); | |
94 | |
95 return rlz_lib::RecordProductEvent(product, access_point, event_id); | |
96 } | |
97 | |
98 bool RlzGetAccessPointRlzFunction::RunImpl() { | |
99 // This can be slow if registry access goes to disk. Should preferably | |
100 // perform registry operations on the File thread. | |
101 // http://code.google.com/p/chromium/issues/detail?id=62098 | |
102 base::ThreadRestrictions::ScopedAllowIO allow_io; | |
103 | |
104 std::string ap_name; | |
105 EXTENSION_FUNCTION_VALIDATE(args_->GetString(0, &ap_name)); | |
106 rlz_lib::AccessPoint access_point; | |
107 EXTENSION_FUNCTION_VALIDATE(rlz_lib::GetAccessPointFromName(ap_name.c_str(), | |
108 &access_point)); | |
109 | |
110 char rlz[rlz_lib::kMaxRlzLength + 1]; | |
111 rlz_lib::GetAccessPointRlz(access_point, rlz, rlz_lib::kMaxRlzLength); | |
112 result_.reset(Value::CreateStringValue(rlz)); | |
113 return true; | |
114 } | |
115 | |
116 bool RlzSendFinancialPingFunction::RunImpl() { | |
117 // This can be slow if registry access goes to disk. Should preferably | |
118 // perform registry operations on the File thread. | |
119 // http://code.google.com/p/chromium/issues/detail?id=62098 | |
120 base::ThreadRestrictions::ScopedAllowIO allow_io; | |
121 | |
122 std::string product_name; | |
123 EXTENSION_FUNCTION_VALIDATE(args_->GetString(0, &product_name)); | |
124 rlz_lib::Product product; | |
125 EXTENSION_FUNCTION_VALIDATE(GetProductFromName(product_name, &product)); | |
126 | |
127 ListValue* access_points_list; | |
128 EXTENSION_FUNCTION_VALIDATE(args_->GetList(1, &access_points_list)); | |
129 if (access_points_list->GetSize() < 1) { | |
130 EXTENSION_FUNCTION_ERROR("Access point array should not be empty."); | |
131 } | |
132 | |
133 // Allocate an access point array to pass to ClearProductState(). The array | |
134 // must be termindated with the value rlz_lib::NO_ACCESS_POINT, hence + 1 | |
135 // when allocating the array. | |
136 scoped_array<rlz_lib::AccessPoint> access_points( | |
137 new rlz_lib::AccessPoint[access_points_list->GetSize() + 1]); | |
138 | |
139 size_t i; | |
140 for (i = 0; i < access_points_list->GetSize(); ++i) { | |
141 std::string ap_name; | |
142 EXTENSION_FUNCTION_VALIDATE(access_points_list->GetString(i, &ap_name)); | |
143 EXTENSION_FUNCTION_VALIDATE(rlz_lib::GetAccessPointFromName( | |
144 ap_name.c_str(), &access_points[i])); | |
145 } | |
146 access_points[i] = rlz_lib::NO_ACCESS_POINT; | |
147 | |
148 std::string signature; | |
149 EXTENSION_FUNCTION_VALIDATE(args_->GetString(2, &signature)); | |
150 | |
151 std::string brand; | |
152 EXTENSION_FUNCTION_VALIDATE(args_->GetString(3, &brand)); | |
153 | |
154 std::string id; | |
155 EXTENSION_FUNCTION_VALIDATE(args_->GetString(4, &id)); | |
156 | |
157 std::string lang; | |
158 EXTENSION_FUNCTION_VALIDATE(args_->GetString(5, &lang)); | |
159 | |
160 bool exclude_machine_id; | |
161 EXTENSION_FUNCTION_VALIDATE(args_->GetBoolean(6, &exclude_machine_id)); | |
162 | |
163 // rlz_lib::SendFinancialPing() will not send a ping more often than once in | |
164 // any 24-hour period. Calling it more often has no effect. If a ping is | |
165 // not sent false is returned, but this is not an error, so we should not | |
166 // use the return value of rlz_lib::SendFinancialPing() as the return value | |
167 // of this function. Callers interested in the return value can register | |
168 // an optional callback function. | |
169 bool sent = rlz_lib::SendFinancialPing(product, access_points.get(), | |
170 signature.c_str(), brand.c_str(), | |
171 id.c_str(), lang.c_str(), | |
172 exclude_machine_id); | |
173 result_.reset(Value::CreateBooleanValue(sent)); | |
174 return true; | |
175 } | |
176 | |
177 bool RlzClearProductStateFunction::RunImpl() { | |
178 // This can be slow if registry access goes to disk. Should preferably | |
179 // perform registry operations on the File thread. | |
180 // http://code.google.com/p/chromium/issues/detail?id=62098 | |
181 base::ThreadRestrictions::ScopedAllowIO allow_io; | |
182 | |
183 std::string product_name; | |
184 EXTENSION_FUNCTION_VALIDATE(args_->GetString(0, &product_name)); | |
185 rlz_lib::Product product; | |
186 EXTENSION_FUNCTION_VALIDATE(GetProductFromName(product_name, &product)); | |
187 | |
188 ListValue* access_points_list; | |
189 EXTENSION_FUNCTION_VALIDATE(args_->GetList(1, &access_points_list)); | |
190 if (access_points_list->GetSize() < 1) { | |
191 EXTENSION_FUNCTION_ERROR("Access point array should not be empty."); | |
192 } | |
193 | |
194 // Allocate an access point array to pass to ClearProductState(). The array | |
195 // must be termindated with the value rlz_lib::NO_ACCESS_POINT, hence + 1 | |
196 // when allocating the array. | |
197 scoped_array<rlz_lib::AccessPoint> access_points( | |
198 new rlz_lib::AccessPoint[access_points_list->GetSize() + 1]); | |
199 | |
200 size_t i; | |
201 for (i = 0; i < access_points_list->GetSize(); ++i) { | |
202 std::string ap_name; | |
203 EXTENSION_FUNCTION_VALIDATE(access_points_list->GetString(i, &ap_name)); | |
204 EXTENSION_FUNCTION_VALIDATE(rlz_lib::GetAccessPointFromName( | |
205 ap_name.c_str(), &access_points[i])); | |
206 } | |
207 access_points[i] = rlz_lib::NO_ACCESS_POINT; | |
208 | |
209 rlz_lib::ClearProductState(product, access_points.get()); | |
210 return true; | |
211 } | |
OLD | NEW |