content/browser/download/mhtml_generation_manager.cc

   1 // Copyright (c) 2012 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 #include "content/browser/download/mhtml_generation_manager.h"
   6
   7 #include "base/bind.h"
   8 #include "base/files/file.h"
   9 #include "base/stl_util.h"
  10 #include "content/browser/renderer_host/render_view_host_impl.h"
  11 #include "content/public/browser/browser_thread.h"
  12 #include "content/public/browser/render_process_host.h"
  13 #include "content/public/browser/render_process_host_observer.h"
  14 #include "content/public/browser/web_contents.h"
  15 #include "content/common/view_messages.h"
  16
  17 namespace content {
  18
  19 class MHTMLGenerationManager::Job : public RenderProcessHostObserver {
  20  public:
  21   Job();
  22   ~Job() override;
  23
  24   void SetWebContents(WebContents* web_contents);
  25
  26   base::File browser_file() { return browser_file_.Pass(); }
  27   void set_browser_file(base::File file) { browser_file_ = file.Pass(); }
  28
  29   int process_id() { return process_id_; }
  30   int routing_id() { return routing_id_; }
  31
  32   GenerateMHTMLCallback callback() { return callback_; }
  33   void set_callback(GenerateMHTMLCallback callback) { callback_ = callback; }
  34
  35   // RenderProcessHostObserver:
  36   void RenderProcessExited(RenderProcessHost* host,
  37                            base::TerminationStatus status,
  38                            int exit_code) override;
  39   void RenderProcessHostDestroyed(RenderProcessHost* host) override;
  40
  41  private:
  42   // The handle to the file the MHTML is saved to for the browser process.
  43   base::File browser_file_;
  44
  45   // The IDs mapping to a specific contents.
  46   int process_id_;
  47   int routing_id_;
  48
  49   // The callback to call once generation is complete.
  50   GenerateMHTMLCallback callback_;
  51
  52   // The RenderProcessHost being observed, or NULL if none is.
  53   RenderProcessHost* host_;
  54   DISALLOW_COPY_AND_ASSIGN(Job);
  55 };
  56
  57 MHTMLGenerationManager::Job::Job()
  58     : process_id_(-1),
  59       routing_id_(-1),
  60       host_(NULL) {
  61 }
  62
  63 MHTMLGenerationManager::Job::~Job() {
  64   if (host_)
  65     host_->RemoveObserver(this);
  66 }
  67
  68 void MHTMLGenerationManager::Job::SetWebContents(WebContents* web_contents) {
  69   process_id_ = web_contents->GetRenderProcessHost()->GetID();
  70   routing_id_ = web_contents->GetRenderViewHost()->GetRoutingID();
  71   host_ = web_contents->GetRenderProcessHost();
  72   host_->AddObserver(this);
  73 }
  74
  75 void MHTMLGenerationManager::Job::RenderProcessExited(
  76     RenderProcessHost* host,
  77     base::TerminationStatus status,
  78     int exit_code) {
  79   MHTMLGenerationManager::GetInstance()->RenderProcessExited(this);
  80 }
  81
  82 void MHTMLGenerationManager::Job::RenderProcessHostDestroyed(
  83     RenderProcessHost* host) {
  84   host_ = NULL;
  85 }
  86
  87 MHTMLGenerationManager* MHTMLGenerationManager::GetInstance() {
  88   return base::Singleton<MHTMLGenerationManager>::get();
  89 }
  90
  91 MHTMLGenerationManager::MHTMLGenerationManager() {
  92 }
  93
  94 MHTMLGenerationManager::~MHTMLGenerationManager() {
  95   STLDeleteValues(&id_to_job_);
  96 }
  97
  98 void MHTMLGenerationManager::SaveMHTML(WebContents* web_contents,
  99                                        const base::FilePath& file,
 100                                        const GenerateMHTMLCallback& callback) {
 101   DCHECK_CURRENTLY_ON(BrowserThread::UI);
 102
 103   int job_id = NewJob(web_contents, callback);
 104
 105   base::ProcessHandle renderer_process =
 106       web_contents->GetRenderProcessHost()->GetHandle();
 107   BrowserThread::PostTask(BrowserThread::FILE, FROM_HERE,
 108       base::Bind(&MHTMLGenerationManager::CreateFile, base::Unretained(this),
 109                  job_id, file, renderer_process));
 110 }
 111
 112 void MHTMLGenerationManager::StreamMHTML(
 113     WebContents* web_contents,
 114     base::File browser_file,
 115     const GenerateMHTMLCallback& callback) {
 116   DCHECK_CURRENTLY_ON(BrowserThread::UI);
 117
 118   int job_id = NewJob(web_contents, callback);
 119
 120   base::ProcessHandle renderer_process =
 121       web_contents->GetRenderProcessHost()->GetHandle();
 122   IPC::PlatformFileForTransit renderer_file =
 123      IPC::GetFileHandleForProcess(browser_file.GetPlatformFile(),
 124                                   renderer_process, false);
 125
 126   FileAvailable(job_id, browser_file.Pass(), renderer_file);
 127 }
 128
 129
 130 void MHTMLGenerationManager::MHTMLGenerated(int job_id, int64 mhtml_data_size) {
 131   JobFinished(job_id, mhtml_data_size);
 132 }
 133
 134 void MHTMLGenerationManager::CreateFile(
 135     int job_id, const base::FilePath& file_path,
 136     base::ProcessHandle renderer_process) {
 137   DCHECK_CURRENTLY_ON(BrowserThread::FILE);
 138   base::File browser_file(
 139       file_path, base::File::FLAG_CREATE_ALWAYS | base::File::FLAG_WRITE);
 140   if (!browser_file.IsValid()) {
 141     LOG(ERROR) << "Failed to create file to save MHTML at: " <<
 142         file_path.value();
 143   }
 144
 145   IPC::PlatformFileForTransit renderer_file =
 146       IPC::GetFileHandleForProcess(browser_file.GetPlatformFile(),
 147                                    renderer_process, false);
 148
 149   BrowserThread::PostTask(
 150       BrowserThread::UI,
 151       FROM_HERE,
 152       base::Bind(&MHTMLGenerationManager::FileAvailable,
 153                  base::Unretained(this),
 154                  job_id,
 155                  base::Passed(&browser_file),
 156                  renderer_file));
 157 }
 158
 159 void MHTMLGenerationManager::FileAvailable(
 160     int job_id,
 161     base::File browser_file,
 162     IPC::PlatformFileForTransit renderer_file) {
 163   DCHECK_CURRENTLY_ON(BrowserThread::UI);
 164   if (!browser_file.IsValid()) {
 165     LOG(ERROR) << "Failed to create file";
 166     JobFinished(job_id, -1);
 167     return;
 168   }
 169
 170   IDToJobMap::iterator iter = id_to_job_.find(job_id);
 171   if (iter == id_to_job_.end()) {
 172     NOTREACHED();
 173     return;
 174   }
 175
 176   Job* job = iter->second;
 177   job->set_browser_file(browser_file.Pass());
 178
 179   RenderViewHost* rvh = RenderViewHost::FromID(
 180       job->process_id(), job->routing_id());
 181   if (!rvh) {
 182     // The contents went away.
 183     JobFinished(job_id, -1);
 184     return;
 185   }
 186
 187   rvh->Send(new ViewMsg_SavePageAsMHTML(rvh->GetRoutingID(), job_id,
 188                                         renderer_file));
 189 }
 190
 191 void MHTMLGenerationManager::JobFinished(int job_id, int64 file_size) {
 192   DCHECK_CURRENTLY_ON(BrowserThread::UI);
 193   IDToJobMap::iterator iter = id_to_job_.find(job_id);
 194   if (iter == id_to_job_.end()) {
 195     NOTREACHED();
 196     return;
 197   }
 198
 199   Job* job = iter->second;
 200   job->callback().Run(file_size);
 201
 202   BrowserThread::PostTask(BrowserThread::FILE, FROM_HERE,
 203       base::Bind(&MHTMLGenerationManager::CloseFile, base::Unretained(this),
 204                  base::Passed(job->browser_file())));
 205
 206   id_to_job_.erase(job_id);
 207   delete job;
 208 }
 209
 210 void MHTMLGenerationManager::CloseFile(base::File file) {
 211   DCHECK_CURRENTLY_ON(BrowserThread::FILE);
 212   file.Close();
 213 }
 214
 215 int MHTMLGenerationManager::NewJob(WebContents* web_contents,
 216                                    const GenerateMHTMLCallback& callback) {
 217   static int id_counter = 0;
 218   int job_id = id_counter++;
 219   Job* job = new Job();
 220   id_to_job_[job_id] = job;
 221   job->SetWebContents(web_contents);
 222   job->set_callback(callback);
 223   return job_id;
 224 }
 225
 226 void MHTMLGenerationManager::RenderProcessExited(Job* job) {
 227   DCHECK_CURRENTLY_ON(BrowserThread::UI);
 228   for (IDToJobMap::iterator it = id_to_job_.begin(); it != id_to_job_.end();
 229        ++it) {
 230     if (it->second == job) {
 231       JobFinished(it->first, -1);
 232       return;
 233     }
 234   }
 235   NOTREACHED();
 236 }
 237
 238 }  // namespace content