chrome/browser/profile_resetter/brandcode_config_fetcher.cc

   1 // Copyright 2013 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/profile_resetter/brandcode_config_fetcher.h"
   6
   7 #include "base/strings/utf_string_conversions.h"
   8 #include "chrome/browser/browser_process.h"
   9 #include "chrome/browser/profile_resetter/brandcoded_default_settings.h"
  10 #include "libxml/parser.h"
  11 #include "net/base/load_flags.h"
  12 #include "net/http/http_response_headers.h"
  13 #include "net/url_request/url_fetcher.h"
  14 #include "net/url_request/url_request_status.h"
  15
  16 namespace {
  17
  18 const int kDownloadTimeoutSec = 10;
  19 const char kPostXml[] =
  20 "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n"
  21 "<request version=\"1.3.17.0\" protocol=\"3.0\" testsource=\"dev\" "
  22     "shell_version=\"1.2.3.5\">\n"
  23 "  <os platform=\"win\" version=\"6.1\" sp=\"\" arch=\"x86\" />\n"
  24 "  <app\n"
  25 "    appid=\"{8A69D345-D564-463C-AFF1-A69D9E530F96}\"\n"
  26 "    version=\"0.0.0.0\"\n"
  27 "      >\n"
  28 "    <updatecheck />\n"
  29 "    <data name=\"install\" "
  30     "index=\"__BRANDCODE_PLACEHOLDER__\" />\n"
  31 "  </app>\n"
  32 "</request>";
  33
  34 // Returns the query to the server which can be used to retrieve the config.
  35 // |brand| is a brand code, it mustn't be empty.
  36 std::string GetUploadData(const std::string& brand) {
  37   DCHECK(!brand.empty());
  38   std::string data(kPostXml);
  39   const std::string placeholder("__BRANDCODE_PLACEHOLDER__");
  40   size_t placeholder_pos = data.find(placeholder);
  41   DCHECK(placeholder_pos != std::string::npos);
  42   data.replace(placeholder_pos, placeholder.size(), brand);
  43   return data;
  44 }
  45
  46 // Extracts json master prefs from xml.
  47 class XmlConfigParser {
  48  public:
  49   XmlConfigParser();
  50   ~XmlConfigParser();
  51
  52   // Returns the content of /response/app/data tag.
  53   static void Parse(const std::string& input_buffer,
  54                     std::string* output_buffer);
  55
  56  private:
  57   static XmlConfigParser* FromContext(void* ctx);
  58   static std::string XMLCharToString(const xmlChar* value);
  59   static void StartElementImpl(void* ctx,
  60                                const xmlChar* name,
  61                                const xmlChar** atts);
  62   static void EndElementImpl(void* ctx, const xmlChar* name);
  63   static void CharactersImpl(void* ctx, const xmlChar* ch, int len);
  64
  65   bool IsParsingData() const;
  66
  67   // Extracted json file.
  68   std::string master_prefs_;
  69
  70   // Current stack of the elements being parsed.
  71   std::vector<std::string> elements_;
  72
  73   DISALLOW_COPY_AND_ASSIGN(XmlConfigParser);
  74 };
  75
  76 XmlConfigParser::XmlConfigParser() {}
  77
  78 XmlConfigParser::~XmlConfigParser() {}
  79
  80 void XmlConfigParser::Parse(const std::string& input_buffer,
  81                             std::string* output_buffer) {
  82   using logging::LOG_WARNING;
  83
  84   DCHECK(output_buffer);
  85   xmlSAXHandler sax_handler = {};
  86   sax_handler.startElement = &XmlConfigParser::StartElementImpl;
  87   sax_handler.endElement = &XmlConfigParser::EndElementImpl;
  88   sax_handler.characters = &XmlConfigParser::CharactersImpl;
  89   XmlConfigParser parser;
  90   int error = xmlSAXUserParseMemory(&sax_handler,
  91                                     &parser,
  92                                     input_buffer.c_str(),
  93                                     input_buffer.size());
  94   if (error) {
  95     VLOG(LOG_WARNING) << "Error parsing brandcoded master prefs, err=" << error;
  96   } else {
  97     output_buffer->swap(parser.master_prefs_);
  98   }
  99 }
 100
 101 XmlConfigParser* XmlConfigParser::FromContext(void* ctx) {
 102   return static_cast<XmlConfigParser*>(ctx);
 103 }
 104
 105 std::string XmlConfigParser::XMLCharToString(const xmlChar* value) {
 106   return std::string(reinterpret_cast<const char*>(value));
 107 }
 108
 109 void XmlConfigParser::StartElementImpl(void* ctx,
 110                                        const xmlChar* name,
 111                                        const xmlChar** atts) {
 112   std::string node_name(XMLCharToString(name));
 113   XmlConfigParser* context = FromContext(ctx);
 114   context->elements_.push_back(node_name);
 115   if (context->IsParsingData())
 116     context->master_prefs_.clear();
 117 }
 118
 119 void XmlConfigParser::EndElementImpl(void* ctx, const xmlChar* name) {
 120   XmlConfigParser* context = FromContext(ctx);
 121   context->elements_.pop_back();
 122 }
 123
 124 void XmlConfigParser::CharactersImpl(void* ctx, const xmlChar* ch, int len) {
 125   XmlConfigParser* context = FromContext(ctx);
 126   if (context->IsParsingData()) {
 127     context->master_prefs_ +=
 128         std::string(reinterpret_cast<const char*>(ch), len);
 129   }
 130 }
 131
 132 bool XmlConfigParser::IsParsingData() const {
 133   const std::string data_path[] = {"response", "app", "data"};
 134   return elements_.size() == arraysize(data_path) &&
 135          std::equal(elements_.begin(), elements_.end(), data_path);
 136 }
 137
 138 } // namespace
 139
 140 BrandcodeConfigFetcher::BrandcodeConfigFetcher(const FetchCallback& callback,
 141                                                const GURL& url,
 142                                                const std::string& brandcode)
 143     : fetch_callback_(callback) {
 144   DCHECK(!brandcode.empty());
 145   config_fetcher_.reset(net::URLFetcher::Create(0 /* ID used for testing */,
 146                                                 url,
 147                                                 net::URLFetcher::POST,
 148                                                 this));
 149   config_fetcher_->SetRequestContext(
 150       g_browser_process->system_request_context());
 151   config_fetcher_->SetUploadData("text/xml", GetUploadData(brandcode));
 152   config_fetcher_->AddExtraRequestHeader("Accept: text/xml");
 153   config_fetcher_->SetLoadFlags(net::LOAD_DO_NOT_SEND_COOKIES |
 154                                 net::LOAD_DO_NOT_SAVE_COOKIES |
 155                                 net::LOAD_DISABLE_CACHE);
 156   config_fetcher_->Start();
 157   // Abort the download attempt if it takes too long.
 158   download_timer_.Start(FROM_HERE,
 159                         base::TimeDelta::FromSeconds(kDownloadTimeoutSec),
 160                         this,
 161                         &BrandcodeConfigFetcher::OnDownloadTimeout);
 162 }
 163
 164 BrandcodeConfigFetcher::~BrandcodeConfigFetcher() {}
 165
 166 void BrandcodeConfigFetcher::SetCallback(const FetchCallback& callback) {
 167   fetch_callback_ = callback;
 168 }
 169
 170 void BrandcodeConfigFetcher::OnURLFetchComplete(const net::URLFetcher* source) {
 171   if (source != config_fetcher_.get()) {
 172     NOTREACHED() << "Callback from foreign URL fetcher";
 173     return;
 174   }
 175   std::string response_string;
 176   std::string mime_type;
 177   if (config_fetcher_ &&
 178       config_fetcher_->GetStatus().is_success() &&
 179       config_fetcher_->GetResponseCode() == 200 &&
 180       config_fetcher_->GetResponseHeaders()->GetMimeType(&mime_type) &&
 181       mime_type == "text/xml" &&
 182       config_fetcher_->GetResponseAsString(&response_string)) {
 183     std::string master_prefs;
 184     XmlConfigParser::Parse(response_string, &master_prefs);
 185     default_settings_.reset(new BrandcodedDefaultSettings(master_prefs));
 186   }
 187   config_fetcher_.reset();
 188   download_timer_.Stop();
 189   fetch_callback_.Run();
 190 }
 191
 192 void BrandcodeConfigFetcher::OnDownloadTimeout() {
 193   if (config_fetcher_) {
 194     config_fetcher_.reset();
 195     fetch_callback_.Run();
 196   }
 197 }