Differential updates for components.

chrome/browser/component_updater/component_updater_service.h

Index: chrome/browser/component_updater/component_updater_service.h
===================================================================
--- chrome/browser/component_updater/component_updater_service.h	(revision 201835)
+++ chrome/browser/component_updater/component_updater_service.h	(working copy)
@@ -8,6 +8,7 @@
 #include <string>
 #include <vector>
 
+#include "base/files/file_path.h"
 #include "base/version.h"
 #include "googleurl/src/gurl.h"
 
@@ -20,6 +21,8 @@
 class FilePath;

[cpu_(ooo_6.6-7.5), 2013/05/29 20:13:58]

note filepath is fwd declared here.

[waffles, 2013/06/13 20:55:04]

Done.

 }
 
+class ComponentPatcher;
+
 // Component specific installers must derive from this class and implement
 // OnUpdateError() and Install(). A valid instance of this class must be
 // given to ComponentUpdateService::RegisterComponent().
@@ -37,6 +40,13 @@
   virtual bool Install(const base::DictionaryValue& manifest,
                        const base::FilePath& unpack_path) = 0;
 
+  // Set |installed_file| to the full path to the installed |file|. |file| is
+  // the filename of the file in this component's CRX. Returns false if this is
+  // not possible (the file has been removed or modified, or its current
+  // location is unknown). Otherwise, returns true.
+  virtual bool GetInstalledFile(const std::string& file,
+                                base::FilePath* installed_file) = 0;
+
  protected:
   virtual ~ComponentInstaller() {}
 };
@@ -55,12 +65,13 @@
   enum UrlSource {
     BANDAID,
     CWS_PUBLIC,
-    CWS_SANDBOX
+    CWS_SANDBOX,
   };
 
   std::vector<uint8> pk_hash;
   ComponentInstaller* installer;
   Version version;
+  std::string fingerprint;

[cpu_(ooo_6.6-7.5), 2013/05/29 20:13:58]

if they have to provide the fingerprint, could this be something that the
ComponentInstaller can do? 

I imagine a scenario where we don't need the fingerprint until we have received
a reply from the server, or is that not how it works?

[waffles, 2013/06/13 20:55:04]

The fingerprint uniquely identifies the installed component (that is, it's a
stronger identifier than appid + version + operating system + etc); we must send
the current fingerprint to the server in the request so that the server knows
which package to give us the differential update from. The server then returns
the new fingerprint along with the response.

So, it feels like it belongs here with pk_hash and version, since it identifies
the currently installed package.

   std::string name;
   UrlSource source;
   CrxComponent();
@@ -116,6 +127,8 @@
     virtual int OnDemandDelay() = 0;
     // The url that is going to be used update checks over Omaha protocol.
     virtual GURL UpdateUrl(CrxComponent::UrlSource source) = 0;
+    // The url where the completion pings are sent.
+    virtual GURL PingUrl() = 0;

[cpu_(ooo_6.6-7.5), 2013/05/29 20:13:58]

hmmm, I already receive complains about undue QPS from the CU, does this mean we
are going to double the traffic to our servers?

[waffles, 2013/06/13 20:55:04]

We've addressed this out of band. For the record, a summary is below.

There will be between 50% and 100% increase in average QPS from the component
updater.
There will be between 60% and 100% increase in peak QPS from the component
updater.
(Increases will be closer to the higher end of this range when multiple
components are releasing, and closer to/at the low end of this range on a daily
basis thanks to CRLSet's 12-hour update cycle.

The services that are going to receive this traffic have given the go-ahead.

     // Parameters added to each url request. It can be null if none are needed.
     virtual const char* ExtraRequestParams() = 0;
     // How big each update request can be. Don't go above 2000.
@@ -128,6 +141,13 @@
     // happens. It should be used mostly as a place to add application specific
     // logging or telemetry. |extra| is |event| dependent.
     virtual void OnEvent(Events event, int extra) = 0;
+    // Creates a new ComponentPatcher in a platform-specific way. This is useful
+    // for dependency injection.
+    virtual ComponentPatcher* CreateComponentPatcher() = 0;
+    // True means that this client can handle delta updates.
+    virtual bool DeltasEnabled() const = 0;
+    // True means this client is allowed to send component update status pings.
+    virtual bool PingsEnabled() const = 0;
   };
 
   // Start doing update checks and installing new versions of registered