OLD | NEW |
---|---|
1 // Copyright 2014 The Chromium Authors. All rights reserved. | 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 | 2 // Use of this source code is governed by a BSD-style license that can be |
3 // found in the LICENSE file. | 3 // found in the LICENSE file. |
4 | 4 |
5 #include "chrome/browser/extensions/zipfile_installer.h" | 5 #include "chrome/browser/extensions/zipfile_installer.h" |
6 | 6 |
7 #include "base/files/file_util.h" | 7 #include "base/files/file_util.h" |
8 #include "base/path_service.h" | 8 #include "base/path_service.h" |
9 #include "base/threading/thread_task_runner_handle.h" | 9 #include "base/threading/thread_task_runner_handle.h" |
10 #include "chrome/browser/extensions/extension_error_reporter.h" | 10 #include "chrome/browser/extensions/extension_error_reporter.h" |
11 #include "chrome/browser/extensions/extension_service.h" | 11 #include "chrome/browser/extensions/extension_service.h" |
12 #include "chrome/browser/extensions/unpacked_installer.h" | 12 #include "chrome/browser/extensions/unpacked_installer.h" |
13 #include "chrome/browser/profiles/profile.h" | 13 #include "chrome/browser/profiles/profile.h" |
14 #include "chrome/grit/generated_resources.h" | 14 #include "chrome/grit/generated_resources.h" |
15 #include "content/public/browser/browser_thread.h" | 15 #include "content/public/browser/browser_thread.h" |
16 #include "content/public/browser/utility_process_host.h" | |
17 #include "extensions/common/extension_utility_messages.h" | |
18 #include "ui/base/l10n/l10n_util.h" | 16 #include "ui/base/l10n/l10n_util.h" |
19 | 17 |
20 using content::BrowserThread; | |
21 using content::UtilityProcessHost; | |
22 | |
23 namespace { | 18 namespace { |
24 | 19 |
25 const char kExtensionHandlerTempDirError[] = | 20 const char kExtensionHandlerTempDirError[] = |
26 "Could not create temporary directory for zipped extension."; | 21 "Could not create temporary directory for zipped extension."; |
22 const char kExtensionHandlerFileUnzipError[] = | |
23 "Could not unzip extension for install."; | |
27 | 24 |
28 } // namespace | 25 } // namespace |
29 | 26 |
30 namespace extensions { | 27 namespace extensions { |
31 | 28 |
32 ZipFileInstaller::ZipFileInstaller(ExtensionService* extension_service) | 29 // static |
33 : be_noisy_on_failure_(true), | 30 scoped_refptr<ZipFileInstaller> ZipFileInstaller::Create( |
34 extension_service_weak_(extension_service->AsWeakPtr()) { | 31 ExtensionService* service) { |
32 DCHECK(service); | |
33 return make_scoped_refptr(new ZipFileInstaller(service)); | |
35 } | 34 } |
36 | 35 |
37 void ZipFileInstaller::LoadFromZipFile(const base::FilePath& path) { | 36 void ZipFileInstaller::LoadFromZipFile(const base::FilePath& zip_file) { |
38 DCHECK_CURRENTLY_ON(BrowserThread::UI); | 37 DCHECK_CURRENTLY_ON(content::BrowserThread::UI); |
39 zip_path_ = path; | 38 |
40 BrowserThread::PostTask(BrowserThread::FILE, | 39 zip_file_ = zip_file; |
41 FROM_HERE, | 40 content::BrowserThread::PostTask( |
42 base::Bind(&ZipFileInstaller::PrepareTempDir, this)); | 41 content::BrowserThread::FILE, FROM_HERE, |
42 base::Bind(&ZipFileInstaller::PrepareTempDir, this)); | |
43 } | 43 } |
44 | 44 |
45 ZipFileInstaller::ZipFileInstaller(ExtensionService* service) | |
46 : be_noisy_on_failure_(true), | |
47 extension_service_weak_(service->AsWeakPtr()) {} | |
48 | |
49 ZipFileInstaller::~ZipFileInstaller() = default; | |
50 | |
45 void ZipFileInstaller::PrepareTempDir() { | 51 void ZipFileInstaller::PrepareTempDir() { |
46 CHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE)); | 52 DCHECK_CURRENTLY_ON(content::BrowserThread::FILE); |
47 base::FilePath temp_dir; | 53 |
48 PathService::Get(base::DIR_TEMP, &temp_dir); | 54 base::FilePath dir_temp; |
49 base::FilePath new_temp_dir; | 55 PathService::Get(base::DIR_TEMP, &dir_temp); |
50 if (!base::CreateTemporaryDirInDir( | 56 |
51 temp_dir, | 57 base::FilePath::StringType dir_name = |
52 zip_path_.RemoveExtension().BaseName().value() + | 58 zip_file_.RemoveExtension().BaseName().value() + FILE_PATH_LITERAL("_"); |
53 FILE_PATH_LITERAL("_"), | 59 |
54 &new_temp_dir)) { | 60 if (!base::CreateTemporaryDirInDir(dir_temp, dir_name, &temp_dir_)) { |
Sam McNally
2017/02/14 05:41:52
This class would be easier to understand if fields
Noel Gordon
2017/02/14 12:35:37
Done. Passed the zip_file path in, passed out the
| |
55 OnUnzipFailed(std::string(kExtensionHandlerTempDirError)); | 61 content::BrowserThread::PostTask( |
62 content::BrowserThread::UI, FROM_HERE, | |
63 base::Bind(&ZipFileInstaller::ReportErrorOnUIThread, this, | |
64 std::string(kExtensionHandlerTempDirError))); | |
56 return; | 65 return; |
57 } | 66 } |
58 BrowserThread::PostTask( | 67 |
59 BrowserThread::IO, | 68 content::BrowserThread::PostTask( |
60 FROM_HERE, | 69 content::BrowserThread::IO, FROM_HERE, |
61 base::Bind(&ZipFileInstaller::StartWorkOnIOThread, this, new_temp_dir)); | 70 base::Bind(&ZipFileInstaller::UnzipOnIOThread, this)); |
62 } | 71 } |
63 | 72 |
64 ZipFileInstaller::~ZipFileInstaller() { | 73 void ZipFileInstaller::UnzipOnIOThread() { |
Sam McNally
2017/02/14 05:41:52
Let's run this on the UI thread instead and let th
Noel Gordon
2017/02/14 12:35:37
Done. Simplifies things and removes the need for L
| |
74 DCHECK_CURRENTLY_ON(content::BrowserThread::IO); | |
75 DCHECK(!utility_process_mojo_client_); | |
76 | |
77 const base::string16 utility_process_name = | |
78 l10n_util::GetStringUTF16(IDS_UTILITY_PROCESS_ZIP_FILE_INSTALLER_NAME); | |
79 | |
80 utility_process_mojo_client_.reset( | |
Sam McNally
2017/02/14 05:41:52
utility_process_mojo_client_ = base::MakeUnique<co
Noel Gordon
2017/02/14 12:35:37
Done.
| |
81 new content::UtilityProcessMojoClient< | |
82 extensions::mojom::ExtensionUnpacker>(utility_process_name)); | |
83 utility_process_mojo_client_->set_error_callback( | |
84 base::Bind(&ZipFileInstaller::UnzipDone, this, false)); | |
85 | |
86 utility_process_mojo_client_->set_exposed_directory(temp_dir_); | |
87 | |
88 utility_process_mojo_client_->Start(); | |
89 | |
90 utility_process_mojo_client_->service()->Unzip( | |
91 zip_file_, temp_dir_, base::Bind(&ZipFileInstaller::UnzipDone, this)); | |
65 } | 92 } |
66 | 93 |
67 // static | 94 void ZipFileInstaller::UnzipDone(bool success) { |
68 scoped_refptr<ZipFileInstaller> ZipFileInstaller::Create( | 95 DCHECK_CURRENTLY_ON(content::BrowserThread::IO); |
69 ExtensionService* extension_service) { | 96 |
70 DCHECK(extension_service); | 97 utility_process_mojo_client_.reset(); |
71 return scoped_refptr<ZipFileInstaller>( | 98 |
72 new ZipFileInstaller(extension_service)); | 99 if (!success) { |
100 content::BrowserThread::PostTask( | |
101 content::BrowserThread::UI, FROM_HERE, | |
102 base::Bind(&ZipFileInstaller::ReportErrorOnUIThread, this, | |
103 std::string(kExtensionHandlerFileUnzipError))); | |
104 return; | |
105 } | |
106 | |
107 content::BrowserThread::PostTask( | |
108 content::BrowserThread::UI, FROM_HERE, | |
109 base::Bind(&ZipFileInstaller::LoadOnUIThread, this)); | |
73 } | 110 } |
74 | 111 |
75 void ZipFileInstaller::StartWorkOnIOThread(const base::FilePath& temp_dir) { | 112 void ZipFileInstaller::LoadOnUIThread() { |
76 CHECK(BrowserThread::CurrentlyOn(BrowserThread::IO)); | 113 DCHECK_CURRENTLY_ON(content::BrowserThread::UI); |
77 UtilityProcessHost* host = | |
78 UtilityProcessHost::Create(this, | |
79 base::ThreadTaskRunnerHandle::Get().get()); | |
80 host->SetName(l10n_util::GetStringUTF16( | |
81 IDS_UTILITY_PROCESS_ZIP_FILE_INSTALLER_NAME)); | |
82 host->SetExposedDir(temp_dir); | |
83 host->Send(new ExtensionUtilityMsg_UnzipToDir(zip_path_, temp_dir)); | |
84 } | |
85 | 114 |
86 void ZipFileInstaller::ReportSuccessOnUIThread( | 115 if (extension_service_weak_) |
87 const base::FilePath& unzipped_path) { | 116 UnpackedInstaller::Create(extension_service_weak_.get())->Load(temp_dir_); |
88 CHECK(BrowserThread::CurrentlyOn(BrowserThread::UI)); | |
89 if (extension_service_weak_.get()) | |
90 UnpackedInstaller::Create(extension_service_weak_.get()) | |
91 ->Load(unzipped_path); | |
92 } | 117 } |
93 | 118 |
94 void ZipFileInstaller::ReportErrorOnUIThread(const std::string& error) { | 119 void ZipFileInstaller::ReportErrorOnUIThread(const std::string& error) { |
95 CHECK(BrowserThread::CurrentlyOn(BrowserThread::UI)); | 120 DCHECK_CURRENTLY_ON(content::BrowserThread::UI); |
96 if (extension_service_weak_.get()) { | 121 |
122 if (extension_service_weak_) { | |
97 ExtensionErrorReporter::GetInstance()->ReportLoadError( | 123 ExtensionErrorReporter::GetInstance()->ReportLoadError( |
98 zip_path_, | 124 zip_file_, error, extension_service_weak_->profile(), |
99 error, | |
100 extension_service_weak_->profile(), | |
101 be_noisy_on_failure_); | 125 be_noisy_on_failure_); |
102 } | 126 } |
103 } | 127 } |
104 | 128 |
105 void ZipFileInstaller::OnUnzipSucceeded(const base::FilePath& unzipped_path) { | |
106 DCHECK_CURRENTLY_ON(BrowserThread::IO); | |
107 BrowserThread::PostTask( | |
108 BrowserThread::UI, | |
109 FROM_HERE, | |
110 base::Bind( | |
111 &ZipFileInstaller::ReportSuccessOnUIThread, this, unzipped_path)); | |
112 } | |
113 | |
114 void ZipFileInstaller::OnUnzipFailed(const std::string& error) { | |
115 DCHECK_CURRENTLY_ON(BrowserThread::IO); | |
116 BrowserThread::PostTask( | |
117 BrowserThread::UI, | |
118 FROM_HERE, | |
119 base::Bind(&ZipFileInstaller::ReportErrorOnUIThread, this, error)); | |
120 } | |
121 | |
122 bool ZipFileInstaller::OnMessageReceived(const IPC::Message& message) { | |
123 bool handled = true; | |
124 IPC_BEGIN_MESSAGE_MAP(ZipFileInstaller, message) | |
125 IPC_MESSAGE_HANDLER(ExtensionUtilityHostMsg_UnzipToDir_Succeeded, | |
126 OnUnzipSucceeded) | |
127 IPC_MESSAGE_HANDLER(ExtensionUtilityHostMsg_UnzipToDir_Failed, OnUnzipFailed) | |
128 IPC_MESSAGE_UNHANDLED(handled = false) | |
129 IPC_END_MESSAGE_MAP() | |
130 return handled; | |
131 } | |
132 | |
133 } // namespace extensions | 129 } // namespace extensions |
OLD | NEW |