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());

[Lei Zhang, 2011/08/19 19:00:23]

I would keep this here and do the check up front in the public
OwnFooTabContents(), rather in the private OwnTabContents() in your CL.

[Sheridan Rawlins, 2011/08/25 22:52:55]

Done.

+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)

[Lei Zhang, 2011/08/19 19:00:23]

I highly prefer to handle the style where we handle error cases and return
early. If |tab_controller| is NULL, in the previous case you'd just stop,
whereas now you'd keep reading the code and wonder if we handle it below
somehow.

[Sheridan Rawlins, 2011/08/25 22:52:55]

Done.

+    initiator_tab = tab_controller->GetInitiatorTab(content->tab_contents());
+  if (initiator_tab) {
+    initiator_tab_wrapper =
+        TabContentsWrapper::GetCurrentWrapperForContents(initiator_tab);
+  }
+
+  bool initiator_tab_exists = initiator_tab_wrapper &&
+      !ReleaseInitiatorTabContents(initiator_tab_wrapper);

[Lei Zhang, 2011/08/19 19:00:23]

Why do you call ReleaseInitiatorTabContents() here? Can't you wait for the print
preview tab to get destroyed, and delete the hidden initiator tab then?

[Sheridan Rawlins, 2011/08/25 22:52:55]

Well, this is the place where we hope to switch to the initiator tab.  If it
will be destroyed, then we don't want to switch to it, so we might as well
delete it too since we know we don't need it anymore.

On 2011/08/19 19:00:23, Lei Zhang wrote:

+  OwnTabContents(content, content, &printing_contents_);
+  // Activate the initiator tab if it exists.
+  if (initiator_tab_exists)
+    static_cast<RenderViewHostDelegate*>(initiator_tab)->Activate();
+}
+
+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, &initiator_contents_);
+
+  return true;
+}
+
+bool BackgroundPrintingManager::ReleaseInitiatorTabContents(
+    TabContentsWrapper* content) {
+  if (initiator_contents_.find(content) == initiator_contents_.end())
+    return false;
+
+  initiator_contents_.erase(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: {
       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);
+      ReleaseInitiatorForPreviewTabContents(tab);
       break;
     }
     case content::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);
+      ReleaseInitiatorForPreviewTabContents(tab);
       break;
     }
     default: {
       NOTREACHED();
       break;
     }
   }
 }
 
+bool BackgroundPrintingManager::ReleaseInitiatorForPreviewTabContents(
+    TabContentsWrapper* preview_content) {
+  printing::PrintPreviewTabController* tab_controller =
+      printing::PrintPreviewTabController::GetInstance();
+
+  if (!tab_controller)
+    return false;
+
+  TabContents* initiator_tab = tab_controller->GetInitiatorTab(
+      preview_content->tab_contents());
+  if (!initiator_tab)
+    return false;
+
+  TabContentsWrapper* initiator_wrapper =
+      TabContentsWrapper::GetCurrentWrapperForContents(initiator_tab);
+
+  return ReleaseInitiatorTabContents(initiator_wrapper);
+}
+
+void BackgroundPrintingManager::OwnTabContents(
+    TabContentsWrapper* contents,
+    TabContentsWrapper* source_contents,
+    TabContentsWrapperSet* wrapper_set) {
+  DCHECK(CalledOnValidThread());
+  DCHECK(!source_contents ||
+         printing::PrintPreviewTabController::IsPrintPreviewTab(
+             source_contents->tab_contents()));
+  CHECK(wrapper_set->find(contents) == wrapper_set->end());
+
+  wrapper_set->insert(contents);
+
+  if (source_contents) {

[Lei Zhang, 2011/08/19 19:00:23]

When is |source_contents| ever NULL? It seems you always pass in a valid
|source_contents|.

[Sheridan Rawlins, 2011/08/25 22:52:55]

Done.

+    if (!registrar_.IsRegistered(this, chrome::NOTIFICATION_PRINT_JOB_RELEASED,
+                                 Source<TabContentsWrapper>(source_contents))) {
+      registrar_.Add(this, chrome::NOTIFICATION_PRINT_JOB_RELEASED,
+                     Source<TabContentsWrapper>(source_contents));
+    }
+    if (!registrar_.IsRegistered(
+            this, content::NOTIFICATION_TAB_CONTENTS_DESTROYED,
+            Source<TabContents>(source_contents->tab_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();
 }
 
+std::set<TabContentsWrapper*>::const_iterator
+    BackgroundPrintingManager::begin_initiator() {
+  return initiator_contents_.begin();
+}
+
+std::set<TabContentsWrapper*>::const_iterator
+    BackgroundPrintingManager::end_initiator() {
+  return initiator_contents_.end();
+}
+
 bool BackgroundPrintingManager::HasTabContents(TabContentsWrapper* entry) {
   return printing_contents_.find(entry) != printing_contents_.end();
 }
 
+bool BackgroundPrintingManager::HasInitiatorTabContents(
+    TabContentsWrapper* entry) {
+  return initiator_contents_.find(entry) != initiator_contents_.end();
+}
+
 }  // namespace printing