chrome/browser/component_updater/update_checker.cc

   1 // Copyright 2014 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/component_updater/update_checker.h"
   6
   7 #include "base/compiler_specific.h"
   8 #include "base/strings/stringprintf.h"
   9 #include "chrome/browser/component_updater/component_updater_utils.h"
  10 #include "chrome/browser/component_updater/crx_update_item.h"
  11 #include "content/public/browser/browser_thread.h"
  12 #include "net/url_request/url_fetcher.h"
  13 #include "net/url_request/url_fetcher_delegate.h"
  14 #include "url/gurl.h"
  15
  16 using content::BrowserThread;
  17
  18 namespace component_updater {
  19
  20 // Builds an update check request for |components|. |additional_attributes| is
  21 // serialized as part of the <request> element of the request to customize it
  22 // with data that is not platform or component specific. For each |item|, a
  23 // corresponding <app> element is created and inserted as a child node of
  24 // the <request>.
  25 //
  26 // An app element looks like this:
  27 //    <app appid="hnimpnehoodheedghdeeijklkeaacbdc"
  28 //         version="0.1.2.3" installsource="ondemand">
  29 //      <updatecheck />
  30 //      <packages>
  31 //        <package fp="abcd" />
  32 //      </packages>
  33 //    </app>
  34 std::string BuildUpdateCheckRequest(const std::vector<CrxUpdateItem*>& items,
  35                                     const std::string& additional_attributes) {
  36   std::string app_elements;
  37   for (size_t i = 0; i != items.size(); ++i) {
  38     const CrxUpdateItem* item = items[i];
  39     std::string app("<app ");
  40     base::StringAppendF(&app,
  41                         "appid=\"%s\" version=\"%s\"",
  42                         item->id.c_str(),
  43                         item->component.version.GetString().c_str());
  44     if (item->on_demand)
  45       base::StringAppendF(&app, " installsource=\"ondemand\"");
  46     base::StringAppendF(&app, ">");
  47     base::StringAppendF(&app, "<updatecheck />");
  48     if (!item->component.fingerprint.empty()) {
  49       base::StringAppendF(&app,
  50                           "<packages>"
  51                           "<package fp=\"%s\"/>"
  52                           "</packages>",
  53                           item->component.fingerprint.c_str());
  54     }
  55     base::StringAppendF(&app, "</app>");
  56     app_elements.append(app);
  57   }
  58
  59   return BuildProtocolRequest(app_elements, additional_attributes);
  60 }
  61
  62 class UpdateCheckerImpl
  63     : public UpdateChecker,
  64       public net::URLFetcherDelegate {
  65  public:
  66   UpdateCheckerImpl(const GURL& url,
  67                     net::URLRequestContextGetter* url_request_context_getter,
  68                     const UpdateCheckCallback& update_check_callback);
  69   virtual ~UpdateCheckerImpl();
  70
  71   // Overrides for UpdateChecker.
  72   virtual bool CheckForUpdates(
  73       const std::vector<CrxUpdateItem*>& items_to_check,
  74       const std::string& additional_attributes) OVERRIDE;
  75
  76   // Overrides for UrlFetcher.
  77   virtual void OnURLFetchComplete(const net::URLFetcher* source) OVERRIDE;
  78
  79  private:
  80   const GURL url_;
  81   net::URLRequestContextGetter* url_request_context_getter_;  // Not owned.
  82   const UpdateCheckCallback update_check_callback_;
  83
  84   scoped_ptr<net::URLFetcher> url_fetcher_;
  85
  86   DISALLOW_COPY_AND_ASSIGN(UpdateCheckerImpl);
  87 };
  88
  89 scoped_ptr<UpdateChecker> UpdateChecker::Create(
  90     const GURL& url,
  91     net::URLRequestContextGetter* url_request_context_getter,
  92     const UpdateCheckCallback& update_check_callback) {
  93   scoped_ptr<UpdateCheckerImpl> update_checker(new UpdateCheckerImpl(
  94       url, url_request_context_getter, update_check_callback));
  95   return update_checker.PassAs<UpdateChecker>();
  96 }
  97
  98 UpdateCheckerImpl::UpdateCheckerImpl(
  99     const GURL& url,
 100     net::URLRequestContextGetter* url_request_context_getter,
 101     const UpdateCheckCallback& update_check_callback)
 102     : url_(url),
 103       url_request_context_getter_(url_request_context_getter),
 104       update_check_callback_(update_check_callback) {
 105   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 106 }
 107
 108 UpdateCheckerImpl::~UpdateCheckerImpl() {
 109   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 110 }
 111
 112 bool UpdateCheckerImpl::CheckForUpdates(
 113     const std::vector<CrxUpdateItem*>& items_to_check,
 114     const std::string& additional_attributes) {
 115   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 116
 117   if (url_fetcher_)
 118     return false;     // Another fetch is in progress.
 119
 120   url_fetcher_.reset(SendProtocolRequest(
 121     url_,
 122     BuildUpdateCheckRequest(items_to_check, additional_attributes),
 123     this,
 124     url_request_context_getter_));
 125
 126   return true;
 127 }
 128
 129 void UpdateCheckerImpl::OnURLFetchComplete(const net::URLFetcher* source) {
 130   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 131   DCHECK(url_fetcher_.get() == source);
 132
 133   int error = 0;
 134   std::string error_message;
 135   UpdateResponse update_response;
 136
 137   if (FetchSuccess(*source)) {
 138     std::string xml;
 139     source->GetResponseAsString(&xml);
 140     if (!update_response.Parse(xml)) {
 141       error = -1;
 142       error_message = update_response.errors();
 143     }
 144   } else {
 145     error = GetFetchError(*source);
 146     error_message.assign("network error");
 147   }
 148
 149   url_fetcher_.reset();
 150   update_check_callback_.Run(error, error_message, update_response.results());
 151 }
 152
 153 }  // namespace component_updater
 154