Add job id to JobEventDetails.

chrome/browser/printing/print_job_worker.cc

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "chrome/browser/printing/print_job_worker.h"
 
 #include <memory>
 #include <string>
 
 #include "base/bind.h"
@@ skipping 72 matching lines @@
       content::RenderFrameHost::FromID(render_process_id_, render_frame_id_);
   return rfh ? content::WebContents::FromRenderFrameHost(rfh) : nullptr;
 }
 
 std::string PrintingContextDelegate::GetAppLocale() {
   return g_browser_process->GetApplicationLocale();
 }
 
 void NotificationCallback(PrintJobWorkerOwner* print_job,
                           JobEventDetails::Type detail_type,
+                          int job_id,
                           PrintedDocument* document,
                           PrintedPage* page) {
-  JobEventDetails* details = new JobEventDetails(detail_type, document, page);
+  JobEventDetails* details =
+      new JobEventDetails(detail_type, job_id, document, page);
   content::NotificationService::current()->Notify(
       chrome::NOTIFICATION_PRINT_JOB_EVENT,
       // We know that is is a PrintJob object in this circumstance.
       content::Source<PrintJob>(static_cast<PrintJob*>(print_job)),
       content::Details<JobEventDetails>(details));
 }
 
 void PostOnOwnerThread(const scoped_refptr<PrintJobWorkerOwner>& owner,
                        const PrintingContext::PrintSettingsCallback& callback,
                        PrintingContext::Result result) {
@@ skipping 257 matching lines @@
   bool result = thread_.Start();
   task_runner_ = thread_.task_runner();
   return result;
 }
 
 void PrintJobWorker::OnDocumentDone() {
   DCHECK(task_runner_->RunsTasksOnCurrentThread());
   DCHECK_EQ(page_number_, PageNumber::npos());
   DCHECK(document_.get());
 
+  int job_id = printing_context_->job_id();
   if (printing_context_->DocumentDone() != PrintingContext::OK) {
     OnFailure();
     return;
   }
 
   owner_->PostTask(FROM_HERE,
                    base::Bind(&NotificationCallback, base::RetainedRef(owner_),
-                              JobEventDetails::DOC_DONE,
+                              JobEventDetails::DOC_DONE, job_id,
                               base::RetainedRef(document_), nullptr));
 
   // Makes sure the variables are reinitialized.
   document_ = NULL;
 }
 
 void PrintJobWorker::SpoolPage(PrintedPage* page) {
   DCHECK(task_runner_->RunsTasksOnCurrentThread());
   DCHECK_NE(page_number_, PageNumber::npos());
 
   // Signal everyone that the page is about to be printed.
   owner_->PostTask(
       FROM_HERE,
       base::Bind(&NotificationCallback, base::RetainedRef(owner_),
-                 JobEventDetails::NEW_PAGE, base::RetainedRef(document_),
-                 base::RetainedRef(page)));
+                 JobEventDetails::NEW_PAGE, printing_context_->job_id(),
+                 base::RetainedRef(document_), base::RetainedRef(page)));
 
   // Preprocess.
   if (printing_context_->NewPage() != PrintingContext::OK) {
     OnFailure();
     return;
   }
 
   // Actual printing.
 #if defined(OS_WIN) || defined(OS_MACOSX)
   document_->RenderPrintedPage(*page, printing_context_->context());
 #elif defined(OS_POSIX)
   document_->RenderPrintedPage(*page, printing_context_.get());
 #endif
 
   // Postprocess.
   if (printing_context_->PageDone() != PrintingContext::OK) {
     OnFailure();
     return;
   }
 
   // Signal everyone that the page is printed.
   owner_->PostTask(
       FROM_HERE,
       base::Bind(&NotificationCallback, base::RetainedRef(owner_),
-                 JobEventDetails::PAGE_DONE, base::RetainedRef(document_),
-                 base::RetainedRef(page)));
+                 JobEventDetails::PAGE_DONE, printing_context_->job_id(),
+                 base::RetainedRef(document_), base::RetainedRef(page)));
 }
 
 void PrintJobWorker::OnFailure() {
   DCHECK(task_runner_->RunsTasksOnCurrentThread());
 
   // We may loose our last reference by broadcasting the FAILED event.
   scoped_refptr<PrintJobWorkerOwner> handle(owner_);
 
   owner_->PostTask(FROM_HERE,
                    base::Bind(&NotificationCallback, base::RetainedRef(owner_),
-                              JobEventDetails::FAILED,
+                              JobEventDetails::FAILED, 0,
                               base::RetainedRef(document_), nullptr));
   Cancel();
 
   // Makes sure the variables are reinitialized.
   document_ = NULL;
   page_number_ = PageNumber::npos();
 }
 
 }  // namespace printing