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