Be able to print items that do window.print(); window.close() (airline tix e.g.)

chrome/browser/printing/background_printing_manager.cc

 // Copyright (c) 2011 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/background_printing_manager.h"
 
 #include "chrome/browser/printing/print_job.h"
 #include "chrome/browser/printing/print_preview_tab_controller.h"
 #include "chrome/browser/sessions/restore_tab_helper.h"
 #include "chrome/browser/tabs/tab_strip_model.h"
@@ skipping 11 matching lines @@
 }
 
 BackgroundPrintingManager::~BackgroundPrintingManager() {
   DCHECK(CalledOnValidThread());
   // The might be some TabContentsWrappers still in |printing_contents_| at
   // this point. E.g. when the last remaining tab is a print preview tab and
   // tries to print. In which case it will fail to print.
   // TODO(thestig) handle this case better.
 }
 
-void BackgroundPrintingManager::OwnTabContents(TabContentsWrapper* contents) {
-  DCHECK(CalledOnValidThread());
+void BackgroundPrintingManager::OwnPreviewTabContents(
+    TabContentsWrapper* content) {
   DCHECK(printing::PrintPreviewTabController::IsPrintPreviewTab(
-      contents->tab_contents()));
-  CHECK(printing_contents_.find(contents) == printing_contents_.end());
+      content->tab_contents()));
+  CHECK(printing_contents_.find(content) == printing_contents_.end());
 
-  printing_contents_.insert(contents);
-
-  registrar_.Add(this, chrome::NOTIFICATION_PRINT_JOB_RELEASED,
-                 Source<TabContentsWrapper>(contents));
-  registrar_.Add(this, content::NOTIFICATION_TAB_CONTENTS_DESTROYED,
-                 Source<TabContents>(contents->tab_contents()));
-
-  // Detach |contents| from its tab strip.
-  Browser* browser = BrowserList::FindBrowserWithID(
-      contents->restore_tab_helper()->window_id().id());
-  DCHECK(browser);
-
-  TabStripModel* tabstrip = browser->tabstrip_model();
-  tabstrip->DetachTabContentsAt(tabstrip->GetIndexOfTabContents(contents));
-
-  // Activate the initiator tab.
+  // Find the initiator tab.
+  TabContents* initiator_tab = NULL;
+  TabContentsWrapper* initiator_tab_wrapper = NULL;
   printing::PrintPreviewTabController* tab_controller =
       printing::PrintPreviewTabController::GetInstance();
-  if (!tab_controller)
-    return;
-  TabContents* initiator_tab = tab_controller->GetInitiatorTab(
-      contents->tab_contents());
-  if (!initiator_tab)
-    return;
-  static_cast<RenderViewHostDelegate*>(initiator_tab)->Activate();
+  if (tab_controller)
+    initiator_tab = tab_controller->GetInitiatorTab(content->tab_contents());
+  if (initiator_tab)
+    initiator_tab_wrapper =
+        TabContentsWrapper::GetCurrentWrapperForContents(initiator_tab);
+  if (initiator_tab_wrapper &&
+      !ReleaseInitiatorTabContents(initiator_tab_wrapper)) {
+    OwnTabContents(content, content);
+
+    // Activate the initiator tab.
+    if (initiator_tab)
+      static_cast<RenderViewHostDelegate*>(initiator_tab)->Activate();
+  } else {
+    OwnTabContents(content, NULL);
+  }
+}
+
+bool BackgroundPrintingManager::OwnInitiatorTabContents(
+    TabContentsWrapper* content) {
+  DCHECK(!printing::PrintPreviewTabController::IsPrintPreviewTab(
+      content->tab_contents()));
+
+  printing::PrintPreviewTabController* tab_controller =
+      printing::PrintPreviewTabController::GetInstance();
+  TabContents* preview_tab =
+      tab_controller->GetPrintPreviewForTab(content->tab_contents());
+  if (!preview_tab)
+    return false;
+  TabContentsWrapper* preview_contents =
+      TabContentsWrapper::GetCurrentWrapperForContents(preview_tab);
+
+  OwnTabContents(content, preview_contents);
+
+  return true;
+}
+
+bool BackgroundPrintingManager::ReleaseInitiatorTabContents(
+    TabContentsWrapper* content) {
+  DLOG(INFO) << __FUNCTION__;
+
+  if (printing_contents_.find(content) == printing_contents_.end())
+    return false;
+
+  printing_contents_.erase(content);
+  DLOG(INFO) << "deleting initiator: " << (void*) content;
+  MessageLoop::current()->DeleteSoon(FROM_HERE, content);
+  return true;
 }
 
 void BackgroundPrintingManager::Observe(int type,
                                         const NotificationSource& source,
                                         const NotificationDetails& details) {
   switch (type) {
     case chrome::NOTIFICATION_PRINT_JOB_RELEASED: {
+      DLOG(INFO) << "NOTIFICATION_PRINT_JOB_RELEASED";
       TabContentsWrapper* tab = Source<TabContentsWrapper>(source).ptr();
       registrar_.Remove(this, chrome::NOTIFICATION_PRINT_JOB_RELEASED,
                         Source<TabContentsWrapper>(tab));
 
       // This might be happening in the middle of a RenderViewGone() loop.
       // Deleting |contents| later so the RenderViewGone() loop can finish.
       MessageLoop::current()->DeleteSoon(FROM_HERE, tab);
+
+      printing::PrintPreviewTabController* tab_controller =
+          printing::PrintPreviewTabController::GetInstance();
+      if (!tab_controller) {
+        DLOG(INFO) << "!tab_controller";
+        break;
+      }
+      TabContents* initiator_tab = tab_controller->GetInitiatorTab(
+          tab->tab_contents());
+      if (!initiator_tab) {
+        DLOG(INFO) << "!initiator_tab";
+        break;
+      }
+      TabContentsWrapper* initiator_wrapper =
+          TabContentsWrapper::GetCurrentWrapperForContents(initiator_tab);
+      ReleaseInitiatorTabContents(initiator_wrapper);
       break;
     }
     case content::NOTIFICATION_TAB_CONTENTS_DESTROYED: {
+      DLOG(INFO) << "NOTIFICATION_TAB_CONTENTS_DESTROYED";
       TabContentsWrapper* tab =
           TabContentsWrapper::GetCurrentWrapperForContents(
               Source<TabContents>(source).ptr());
       if (registrar_.IsRegistered(this, chrome::NOTIFICATION_PRINT_JOB_RELEASED,
                                   Source<TabContentsWrapper>(tab))) {
         registrar_.Remove(this, chrome::NOTIFICATION_PRINT_JOB_RELEASED,
                           Source<TabContentsWrapper>(tab));
       }
       registrar_.Remove(this, content::NOTIFICATION_TAB_CONTENTS_DESTROYED,
                         Source<TabContents>(tab->tab_contents()));
       printing_contents_.erase(tab);
+      printing::PrintPreviewTabController* tab_controller =
+          printing::PrintPreviewTabController::GetInstance();
+      if (!tab_controller) {
+        DLOG(INFO) << "!tab_controller";
+        break;
+      }
+      TabContents* initiator_tab = tab_controller->GetInitiatorTab(
+          tab->tab_contents());
+      if (!initiator_tab) {
+        DLOG(INFO) << "!initiator_tab";
+        break;
+      }
+      TabContentsWrapper* initiator_wrapper =
+          TabContentsWrapper::GetCurrentWrapperForContents(initiator_tab);
+      DLOG(INFO) << (void*)initiator_wrapper;
+      ReleaseInitiatorTabContents(initiator_wrapper);
       break;
     }
     default: {
       NOTREACHED();
       break;
     }
   }
 }
 
+void BackgroundPrintingManager::OwnTabContents(
+    TabContentsWrapper* contents, TabContentsWrapper* source_contents) {
+  DCHECK(CalledOnValidThread());
+  DCHECK(!source_contents ||
+         printing::PrintPreviewTabController::IsPrintPreviewTab(
+             source_contents->tab_contents()));
+  CHECK(printing_contents_.find(contents) == printing_contents_.end());
+
+  printing_contents_.insert(contents);
+
+  if (source_contents) {
+    // TODO(scr) delete non-preview tab if print is deleted or finishes.
+    registrar_.Add(this, chrome::NOTIFICATION_PRINT_JOB_RELEASED,
+                   Source<TabContentsWrapper>(source_contents));
+    registrar_.Add(this, content::NOTIFICATION_TAB_CONTENTS_DESTROYED,
+                   Source<TabContents>(source_contents->tab_contents()));
+  }
+
+  // Detach |contents| from its tab strip.
+  Browser* browser = BrowserList::FindBrowserWithID(
+      contents->restore_tab_helper()->window_id().id());
+  DCHECK(browser);
+
+  TabStripModel* tabstrip = browser->tabstrip_model();
+  tabstrip->DetachTabContentsAt(tabstrip->GetIndexOfTabContents(contents));
+}
+
 std::set<TabContentsWrapper*>::const_iterator
     BackgroundPrintingManager::begin() {
   return printing_contents_.begin();
 }
 
 std::set<TabContentsWrapper*>::const_iterator
     BackgroundPrintingManager::end() {
   return printing_contents_.end();
 }
 
 bool BackgroundPrintingManager::HasTabContents(TabContentsWrapper* entry) {
   return printing_contents_.find(entry) != printing_contents_.end();
 }
 
 }  // namespace printing