OLD | NEW |
| (Empty) |
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 #ifndef COMPONENTS_COMPONENT_UPDATER_COMPONENT_PATCHER_OPERATION_H_ | |
6 #define COMPONENTS_COMPONENT_UPDATER_COMPONENT_PATCHER_OPERATION_H_ | |
7 | |
8 #include <string> | |
9 | |
10 #include "base/callback.h" | |
11 #include "base/compiler_specific.h" | |
12 #include "base/files/file_path.h" | |
13 #include "base/macros.h" | |
14 #include "base/memory/ref_counted.h" | |
15 #include "components/component_updater/component_unpacker.h" | |
16 | |
17 namespace base { | |
18 class DictionaryValue; | |
19 } // namespace base | |
20 | |
21 namespace component_updater { | |
22 | |
23 extern const char kOp[]; | |
24 extern const char kBsdiff[]; | |
25 extern const char kCourgette[]; | |
26 extern const char kInput[]; | |
27 extern const char kPatch[]; | |
28 | |
29 class ComponentInstaller; | |
30 | |
31 class DeltaUpdateOp : public base::RefCountedThreadSafe<DeltaUpdateOp> { | |
32 public: | |
33 DeltaUpdateOp(); | |
34 | |
35 // Parses, runs, and verifies the operation. Calls |callback| with the | |
36 // result of the operation. The callback is called using |task_runner|. | |
37 void Run(const base::DictionaryValue* command_args, | |
38 const base::FilePath& input_dir, | |
39 const base::FilePath& unpack_dir, | |
40 ComponentInstaller* installer, | |
41 const ComponentUnpacker::Callback& callback, | |
42 scoped_refptr<base::SequencedTaskRunner> task_runner); | |
43 | |
44 protected: | |
45 virtual ~DeltaUpdateOp(); | |
46 | |
47 scoped_refptr<base::SequencedTaskRunner> GetTaskRunner(); | |
48 | |
49 std::string output_sha256_; | |
50 base::FilePath output_abs_path_; | |
51 | |
52 private: | |
53 friend class base::RefCountedThreadSafe<DeltaUpdateOp>; | |
54 | |
55 ComponentUnpacker::Error CheckHash(); | |
56 | |
57 // Subclasses must override DoParseArguments to parse operation-specific | |
58 // arguments. DoParseArguments returns DELTA_OK on success; any other code | |
59 // represents failure. | |
60 virtual ComponentUnpacker::Error DoParseArguments( | |
61 const base::DictionaryValue* command_args, | |
62 const base::FilePath& input_dir, | |
63 ComponentInstaller* installer) = 0; | |
64 | |
65 // Subclasses must override DoRun to actually perform the patching operation. | |
66 // They must call the provided callback when they have completed their | |
67 // operations. In practice, the provided callback is always for "DoneRunning". | |
68 virtual void DoRun(const ComponentUnpacker::Callback& callback) = 0; | |
69 | |
70 // Callback given to subclasses for when they complete their operation. | |
71 // Validates the output, and posts a task to the patching operation's | |
72 // callback. | |
73 void DoneRunning(ComponentUnpacker::Error error, int extended_error); | |
74 | |
75 ComponentUnpacker::Callback callback_; | |
76 scoped_refptr<base::SequencedTaskRunner> task_runner_; | |
77 | |
78 DISALLOW_COPY_AND_ASSIGN(DeltaUpdateOp); | |
79 }; | |
80 | |
81 // A 'copy' operation takes a file currently residing on the disk and moves it | |
82 // into the unpacking directory: this represents "no change" in the file being | |
83 // installed. | |
84 class DeltaUpdateOpCopy : public DeltaUpdateOp { | |
85 public: | |
86 DeltaUpdateOpCopy(); | |
87 | |
88 private: | |
89 ~DeltaUpdateOpCopy() override; | |
90 | |
91 // Overrides of DeltaUpdateOp. | |
92 ComponentUnpacker::Error DoParseArguments( | |
93 const base::DictionaryValue* command_args, | |
94 const base::FilePath& input_dir, | |
95 ComponentInstaller* installer) override; | |
96 | |
97 void DoRun(const ComponentUnpacker::Callback& callback) override; | |
98 | |
99 base::FilePath input_abs_path_; | |
100 | |
101 DISALLOW_COPY_AND_ASSIGN(DeltaUpdateOpCopy); | |
102 }; | |
103 | |
104 // A 'create' operation takes a full file that was sent in the delta update | |
105 // archive and moves it into the unpacking directory: this represents the | |
106 // addition of a new file, or a file so different that no bandwidth could be | |
107 // saved by transmitting a differential update. | |
108 class DeltaUpdateOpCreate : public DeltaUpdateOp { | |
109 public: | |
110 DeltaUpdateOpCreate(); | |
111 | |
112 private: | |
113 ~DeltaUpdateOpCreate() override; | |
114 | |
115 // Overrides of DeltaUpdateOp. | |
116 ComponentUnpacker::Error DoParseArguments( | |
117 const base::DictionaryValue* command_args, | |
118 const base::FilePath& input_dir, | |
119 ComponentInstaller* installer) override; | |
120 | |
121 void DoRun(const ComponentUnpacker::Callback& callback) override; | |
122 | |
123 base::FilePath patch_abs_path_; | |
124 | |
125 DISALLOW_COPY_AND_ASSIGN(DeltaUpdateOpCreate); | |
126 }; | |
127 | |
128 // An interface an embedder may fulfill to enable out-of-process patching. | |
129 class OutOfProcessPatcher | |
130 : public base::RefCountedThreadSafe<OutOfProcessPatcher> { | |
131 public: | |
132 virtual void Patch(const std::string& operation, | |
133 scoped_refptr<base::SequencedTaskRunner> task_runner, | |
134 const base::FilePath& input_abs_path, | |
135 const base::FilePath& patch_abs_path, | |
136 const base::FilePath& output_abs_path, | |
137 base::Callback<void(int result)> callback) = 0; | |
138 | |
139 protected: | |
140 friend class base::RefCountedThreadSafe<OutOfProcessPatcher>; | |
141 | |
142 virtual ~OutOfProcessPatcher() {} | |
143 }; | |
144 | |
145 // Both 'bsdiff' and 'courgette' operations take an existing file on disk, | |
146 // and a bsdiff- or Courgette-format patch file provided in the delta update | |
147 // package, and run bsdiff or Courgette to construct an output file in the | |
148 // unpacking directory. | |
149 class DeltaUpdateOpPatch : public DeltaUpdateOp { | |
150 public: | |
151 // |out_of_process_patcher| may be NULL. | |
152 DeltaUpdateOpPatch(const std::string& operation, | |
153 scoped_refptr<OutOfProcessPatcher> out_of_process_patcher); | |
154 | |
155 private: | |
156 ~DeltaUpdateOpPatch() override; | |
157 | |
158 // Overrides of DeltaUpdateOp. | |
159 ComponentUnpacker::Error DoParseArguments( | |
160 const base::DictionaryValue* command_args, | |
161 const base::FilePath& input_dir, | |
162 ComponentInstaller* installer) override; | |
163 | |
164 void DoRun(const ComponentUnpacker::Callback& callback) override; | |
165 | |
166 // |success_code| is the code that indicates a successful patch. | |
167 // |result| is the code the patching operation returned. | |
168 void DonePatching(const ComponentUnpacker::Callback& callback, int result); | |
169 | |
170 std::string operation_; | |
171 scoped_refptr<OutOfProcessPatcher> out_of_process_patcher_; | |
172 base::FilePath patch_abs_path_; | |
173 base::FilePath input_abs_path_; | |
174 | |
175 DISALLOW_COPY_AND_ASSIGN(DeltaUpdateOpPatch); | |
176 }; | |
177 | |
178 DeltaUpdateOp* CreateDeltaUpdateOp( | |
179 const std::string& operation, | |
180 scoped_refptr<OutOfProcessPatcher> out_of_process_patcher); | |
181 | |
182 } // namespace component_updater | |
183 | |
184 #endif // COMPONENTS_COMPONENT_UPDATER_COMPONENT_PATCHER_OPERATION_H_ | |
OLD | NEW |