src/chrome/browser/component_updater/component_patcher_operation.h

   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 #ifndef CHROME_BROWSER_COMPONENT_UPDATER_COMPONENT_PATCHER_OPERATION_H_
   6 #define CHROME_BROWSER_COMPONENT_UPDATER_COMPONENT_PATCHER_OPERATION_H_
   7
   8 #include <string>
   9 #include "base/basictypes.h"
  10 #include "base/compiler_specific.h"
  11 #include "chrome/browser/component_updater/component_unpacker.h"
  12
  13 namespace base {
  14
  15 class FilePath;
  16 class DictionaryValue;
  17
  18 }  // namespace base
  19
  20 class ComponentInstaller;
  21 class ComponentPatcher;
  22
  23 class DeltaUpdateOp {
  24  public:
  25
  26   DeltaUpdateOp();
  27   virtual ~DeltaUpdateOp();
  28
  29   // Parses, runs, and verifies the operation, returning an error code if an
  30   // error is encountered, and DELTA_OK otherwise. In case of errors,
  31   // extended error information can be returned in the |error| parameter.
  32   ComponentUnpacker::Error Run(
  33       base::DictionaryValue* command_args,
  34       const base::FilePath& input_dir,
  35       const base::FilePath& unpack_dir,
  36       ComponentPatcher* patcher,
  37       ComponentInstaller* installer,
  38       int* error);
  39
  40  protected:
  41   std::string output_sha256_;
  42   base::FilePath output_abs_path_;
  43
  44  private:
  45   ComponentUnpacker::Error CheckHash();
  46
  47   // Subclasses must override DoParseArguments to parse operation-specific
  48   // arguments. DoParseArguments returns DELTA_OK on success; any other code
  49   // represents failure.
  50   virtual ComponentUnpacker::Error DoParseArguments(
  51       base::DictionaryValue* command_args,
  52       const base::FilePath& input_dir,
  53       ComponentInstaller* installer) = 0;
  54
  55   // Subclasses must override DoRun to actually perform the patching operation.
  56   // DoRun returns DELTA_OK on success; any other code represents failure.
  57   // Additional error information can be returned in the |error| parameter.
  58   virtual ComponentUnpacker::Error DoRun(ComponentPatcher* patcher,
  59                                          int* error) = 0;
  60
  61   DISALLOW_COPY_AND_ASSIGN(DeltaUpdateOp);
  62 };
  63
  64 // A 'copy' operation takes a file currently residing on the disk and moves it
  65 // into the unpacking directory: this represents "no change" in the file being
  66 // installed.
  67 class DeltaUpdateOpCopy : public DeltaUpdateOp {
  68  public:
  69   DeltaUpdateOpCopy();
  70
  71  private:
  72   // Overrides of DeltaUpdateOp.
  73   virtual ComponentUnpacker::Error DoParseArguments(
  74       base::DictionaryValue* command_args,
  75       const base::FilePath& input_dir,
  76       ComponentInstaller* installer) OVERRIDE;
  77
  78   virtual ComponentUnpacker::Error DoRun(ComponentPatcher* patcher,
  79                                          int* error) OVERRIDE;
  80
  81   base::FilePath input_abs_path_;
  82
  83   DISALLOW_COPY_AND_ASSIGN(DeltaUpdateOpCopy);
  84 };
  85
  86 // A 'create' operation takes a full file that was sent in the delta update
  87 // archive and moves it into the unpacking directory: this represents the
  88 // addition of a new file, or a file so different that no bandwidth could be
  89 // saved by transmitting a differential update.
  90 class DeltaUpdateOpCreate : public DeltaUpdateOp {
  91  public:
  92   DeltaUpdateOpCreate();
  93
  94  private:
  95   // Overrides of DeltaUpdateOp.
  96   virtual ComponentUnpacker::Error DoParseArguments(
  97       base::DictionaryValue* command_args,
  98       const base::FilePath& input_dir,
  99       ComponentInstaller* installer) OVERRIDE;
 100
 101   virtual ComponentUnpacker::Error DoRun(ComponentPatcher* patcher,
 102                                          int* error) OVERRIDE;
 103
 104   base::FilePath patch_abs_path_;
 105
 106   DISALLOW_COPY_AND_ASSIGN(DeltaUpdateOpCreate);
 107 };
 108
 109 // A 'bsdiff' operation takes an existing file on disk, and a bsdiff-
 110 // format patch file provided in the delta update package, and runs bsdiff
 111 // to construct an output file in the unpacking directory.
 112 class DeltaUpdateOpPatchBsdiff : public DeltaUpdateOp {
 113  public:
 114   DeltaUpdateOpPatchBsdiff();
 115
 116  private:
 117   // Overrides of DeltaUpdateOp.
 118   virtual ComponentUnpacker::Error DoParseArguments(
 119       base::DictionaryValue* command_args,
 120       const base::FilePath& input_dir,
 121       ComponentInstaller* installer) OVERRIDE;
 122
 123   virtual ComponentUnpacker::Error DoRun(ComponentPatcher* patcher,
 124                                          int* error) OVERRIDE;
 125
 126   base::FilePath patch_abs_path_;
 127   base::FilePath input_abs_path_;
 128
 129   DISALLOW_COPY_AND_ASSIGN(DeltaUpdateOpPatchBsdiff);
 130 };
 131
 132 // A 'courgette' operation takes an existing file on disk, and a Courgette-
 133 // format patch file provided in the delta update package, and runs Courgette
 134 // to construct an output file in the unpacking directory.
 135 class DeltaUpdateOpPatchCourgette : public DeltaUpdateOp {
 136  public:
 137   DeltaUpdateOpPatchCourgette();
 138
 139  private:
 140   // Overrides of DeltaUpdateOp.
 141   virtual ComponentUnpacker::Error DoParseArguments(
 142       base::DictionaryValue* command_args,
 143       const base::FilePath& input_dir,
 144       ComponentInstaller* installer) OVERRIDE;
 145
 146   virtual ComponentUnpacker::Error DoRun(ComponentPatcher* patcher,
 147                                          int* error) OVERRIDE;
 148
 149   base::FilePath patch_abs_path_;
 150   base::FilePath input_abs_path_;
 151
 152   DISALLOW_COPY_AND_ASSIGN(DeltaUpdateOpPatchCourgette);
 153 };
 154
 155 // Factory function to create DeltaUpdateOp instances.
 156 DeltaUpdateOp* CreateDeltaUpdateOp(base::DictionaryValue* command);
 157
 158 #endif  // CHROME_BROWSER_COMPONENT_UPDATER_COMPONENT_PATCHER_OPERATION_H_