chrome/browser/rlz/rlz_extension_api.cc

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