Differential updates for components.

chrome/browser/component_updater/component_updater_configurator.cc

 // Copyright (c) 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.
 
 #include "chrome/browser/component_updater/component_updater_configurator.h"
 
 #include <algorithm>
 #include <string>
 #include <vector>
 
 #include "base/command_line.h"
 #include "base/compiler_specific.h"
 #include "base/metrics/histogram.h"
 #include "base/strings/string_util.h"
 #include "base/win/windows_version.h"
 #include "build/build_config.h"
+#include "chrome/browser/component_updater/component_patcher.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/common/omaha_query_params/omaha_query_params.h"
 #include "net/url_request/url_request_context_getter.h"
 
+#if defined(OS_WIN)
+#include "chrome/browser/component_updater/component_patcher_win.h"
+#endif
+
 namespace {
+
 // Default time constants.
 const int kDelayOneMinute = 60;
 const int kDelayOneHour = kDelayOneMinute * 60;
 
 // Debug values you can pass to --component-updater-debug=value1,value2.
 // Speed up component checking.
 const char kDebugFastUpdate[] = "fast-update";
 // Force out-of-process-xml parsing.
 const char kDebugOutOfProcess[] = "out-of-process";
 // Add "testrequest=1" parameter to the update check query.
 const char kDebugRequestParam[] = "test-request";
 
 // The urls from which an update manifest can be fetched.
 const char* kUrlSources[] = {
   "http://clients2.google.com/service/update2/crx",       // BANDAID
   "http://omaha.google.com/service/update2/crx",          // CWS_PUBLIC
-  "http://omaha.sandbox.google.com/service/update2/crx"   // CWS_SANDBOX
+  "http://omaha.sandbox.google.com/service/update2/crx",   // CWS_SANDBOX
 };
 
+// The url to send the completion pings to. Completion pings are sent when
+// updates have completed, either successfully or with errors.
+const char kUrlPing[] = "http://tools.google.com/service/update2";
+
 bool HasDebugValue(const std::vector<std::string>& vec, const char* test) {
   if (vec.empty())
     return 0;
   return (std::find(vec.begin(), vec.end(), test) != vec.end());
 }
 
 }  // namespace
 
 class ChromeConfigurator : public ComponentUpdateService::Configurator {
  public:
   ChromeConfigurator(const CommandLine* cmdline,
                      net::URLRequestContextGetter* url_request_getter);
 
   virtual ~ChromeConfigurator() {}
 
   virtual int InitialDelay() OVERRIDE;
   virtual int NextCheckDelay() OVERRIDE;
   virtual int StepDelay() OVERRIDE;
   virtual int MinimumReCheckWait() OVERRIDE;
   virtual int OnDemandDelay() OVERRIDE;
   virtual GURL UpdateUrl(CrxComponent::UrlSource source) OVERRIDE;
+  virtual GURL PingUrl() OVERRIDE;
   virtual const char* ExtraRequestParams() OVERRIDE;
   virtual size_t UrlSizeLimit() OVERRIDE;
   virtual net::URLRequestContextGetter* RequestContext() OVERRIDE;
   virtual bool InProcess() OVERRIDE;
   virtual void OnEvent(Events event, int val) OVERRIDE;
+  virtual ComponentPatcher* CreateComponentPatcher() OVERRIDE;
+  virtual bool DeltasEnabled() const OVERRIDE;
 
  private:
   net::URLRequestContextGetter* url_request_getter_;
   std::string extra_info_;
   bool fast_update_;
   bool out_of_process_;
+  bool pings_enabled_;
+  bool deltas_enabled_;
 };
 
 ChromeConfigurator::ChromeConfigurator(const CommandLine* cmdline,
     net::URLRequestContextGetter* url_request_getter)
       : url_request_getter_(url_request_getter),
         extra_info_(chrome::OmahaQueryParams::Get(
-            chrome::OmahaQueryParams::CHROME)) {
+            chrome::OmahaQueryParams::CHROME)),
+        fast_update_(false),
+        out_of_process_(false),
+        pings_enabled_(false),

[cpu_(ooo_6.6-7.5), 2013/06/18 22:45:52]

do we want pings disabled by default?

Is the plan to have all users ping, eventually? if so it is best to start in
'on' in canary since the smaller population has less change of DoS ing us.

[waffles, 2013/06/19 00:02:11]

I'm planning on submitting another changelist almost immediately after this one
goes in to flip the flags to be on by default. I thought doing the flag flip in
a separate CL would be nice if it's necessary to revert. Is that a good plan?

+        deltas_enabled_(false) {
   // Parse comma-delimited debug flags.
   std::vector<std::string> debug_values;
   Tokenize(cmdline->GetSwitchValueASCII(switches::kComponentUpdaterDebug),
       ",", &debug_values);
   fast_update_ = HasDebugValue(debug_values, kDebugFastUpdate);
   out_of_process_ = HasDebugValue(debug_values, kDebugOutOfProcess);
 
+  // Parse other command-ling flags.
+  pings_enabled_ = cmdline->HasSwitch(switches::kEnableComponentUpdatePings);

[cpu_(ooo_6.6-7.5), 2013/06/18 22:45:52]

probably best if we can use the existing scheme, it uses a single switch
--component-updater-debug= comma separated values here, instead of top level
chrome switches, maybe we can shorten it to just be component-updater

--component-updater=use-deltas,fast-update.

See lines 32, to 38.

[waffles, 2013/06/19 00:02:11]

Hm, that's an interesting idea.

I have two concerns:
1) I'm worried about changing --component-updater-debug to something else
because I'm not sure what testing (automated or manual) relies on the flag, and
finding all the manual test playbooks seems like a daunting task.
2) My understanding was that the switches in the switches file are automatically
documented, whereas nested flags (fast-update and so on) seem pretty difficult
to automatically document - does this mean that having the highly-visible
standalone switches is preferred?

Let me know what you think.

[waffles, 2013/06/20 04:53:33]

Done.

+#if defined(OS_WIN)
+  deltas_enabled_ = cmdline->HasSwitch(switches::kEnableComponentUpdateDeltas);
+#else
+  deltas_enabled_ = false;
+#endif
+
   // Make the extra request params, they are necessary so omaha does
   // not deliver components that are going to be rejected at install time.
 #if defined(OS_WIN)
   if (base::win::OSInfo::GetInstance()->wow64_status() ==
       base::win::OSInfo::WOW64_ENABLED)
     extra_info_ += "&wow64=1";
 #endif
   if (HasDebugValue(debug_values, kDebugRequestParam))
     extra_info_ += "&testrequest=1";
 }
@@ skipping 15 matching lines @@
 }
 
 int ChromeConfigurator::OnDemandDelay() {
   return fast_update_ ? 2 : (30 * kDelayOneMinute);
 }
 
 GURL ChromeConfigurator::UpdateUrl(CrxComponent::UrlSource source) {
   return GURL(kUrlSources[source]);
 }
 
+GURL ChromeConfigurator::PingUrl() {
+  return pings_enabled_ ? GURL(kUrlPing) : GURL();
+}
+
 const char* ChromeConfigurator::ExtraRequestParams() {
   return extra_info_.c_str();
 }
 
 size_t ChromeConfigurator::UrlSizeLimit() {
   return 1024ul;
 }
 
 net::URLRequestContextGetter* ChromeConfigurator::RequestContext() {
   return url_request_getter_;
@@ skipping 22 matching lines @@
       break;
     case kInstallerError:
       UMA_HISTOGRAM_ENUMERATION("ComponentUpdater.InstallError", val, 100);
       break;
     default:
       NOTREACHED();
       break;
   }
 }
 
+ComponentPatcher* ChromeConfigurator::CreateComponentPatcher() {
+#if defined(OS_WIN)
+  return new ComponentPatcherWin();
+#else
+  return new ComponentPatcherCrossPlatform();
+#endif
+}
+
+bool ChromeConfigurator::DeltasEnabled() const {
+  return deltas_enabled_;
+}
+
 ComponentUpdateService::Configurator* MakeChromeComponentUpdaterConfigurator(
     const CommandLine* cmdline, net::URLRequestContextGetter* context_getter) {
   return new ChromeConfigurator(cmdline, context_getter);
 }