Print Preview: Handle a crashed initiator tab by showing a message in PP.

chrome/browser/printing/print_preview_tab_controller.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/print_preview_tab_controller.h"
 
 #include "base/command_line.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/sessions/restore_tab_helper.h"
 #include "chrome/browser/tabs/tab_strip_model.h"
 #include "chrome/browser/ui/browser.h"
 #include "chrome/browser/ui/browser_list.h"
 #include "chrome/browser/ui/browser_navigator.h"
 #include "chrome/browser/ui/tab_contents/tab_contents_wrapper.h"
 #include "chrome/browser/ui/webui/print_preview_ui.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/common/url_constants.h"
+#include "content/browser/renderer_host/render_view_host.h"
 #include "content/browser/tab_contents/navigation_details.h"
 #include "content/browser/tab_contents/tab_contents.h"
+#include "content/common/content_notification_types.h"
 #include "content/common/notification_details.h"
 #include "content/common/notification_source.h"
 
 namespace printing {
 
 PrintPreviewTabController::PrintPreviewTabController()
     : waiting_for_new_preview_page_(false) {
 }
 
 PrintPreviewTabController::~PrintPreviewTabController() {}
 
 // static
 PrintPreviewTabController* PrintPreviewTabController::GetInstance() {
   if (!g_browser_process)
     return NULL;
   return g_browser_process->print_preview_tab_controller();
 }
 
 // static
 void PrintPreviewTabController::PrintPreview(TabContents* tab) {
   if (tab->showing_interstitial_page())
     return;
 
   printing::PrintPreviewTabController* tab_controller =
       printing::PrintPreviewTabController::GetInstance();
   if (!tab_controller)
     return;
+
   tab_controller->GetOrCreatePreviewTab(tab);
 }
 
 TabContents* PrintPreviewTabController::GetOrCreatePreviewTab(
     TabContents* initiator_tab) {
   DCHECK(initiator_tab);
 
   // Get the print preview tab for |initiator_tab|.
   TabContents* preview_tab = GetPrintPreviewForTab(initiator_tab);
   if (preview_tab) {
     // Show current preview tab.
     static_cast<RenderViewHostDelegate*>(preview_tab)->Activate();
     return preview_tab;
   }
+
   return CreatePrintPreviewTab(initiator_tab);
 }
 
 TabContents* PrintPreviewTabController::GetPrintPreviewForTab(
     TabContents* tab) const {
+  // |preview_tab_map_| is keyed by the preview tab, so if find() succeeds, then
+  // |tab| is the preview tab.
   PrintPreviewTabMap::const_iterator it = preview_tab_map_.find(tab);
   if (it != preview_tab_map_.end())
     return tab;
 
   for (it = preview_tab_map_.begin(); it != preview_tab_map_.end(); ++it) {
     // If |tab| is an initiator tab.
     if (tab == it->second) {
       // Return the associated preview tab.
       return it->first;
     }
   }
+
   return NULL;
 }
 
 void PrintPreviewTabController::Observe(int type,
                                         const NotificationSource& source,
                                         const NotificationDetails& details) {
-  TabContents* source_tab = NULL;
-  content::LoadCommittedDetails* detail_info = NULL;
-
   switch (type) {
+    case content::NOTIFICATION_RENDERER_PROCESS_CLOSED: {

[Lei Zhang, 2011/08/09 20:51:19]

If we just close a tab, do we get this notification? Or do we get
NOTIFICATION_TAB_CONTENTS_DESTORYED first?

[kmadhusu, 2011/08/10 16:46:59]

When a tab is closed, we do not get this notification. We only get
NOTIFICATION_TAB_CONTENTS_DESTROYED. This notification is only to notify crashed
tabs.

+      OnRendererProcessClosed(Source<RenderProcessHost>(source).ptr());
+      break;
+    }
     case content::NOTIFICATION_TAB_CONTENTS_DESTROYED: {
-      source_tab = Source<TabContents>(source).ptr();
+      OnTabContentsDestroyed(Source<TabContents>(source).ptr());
       break;
     }
     case content::NOTIFICATION_NAV_ENTRY_COMMITTED: {
       NavigationController* controller =
           Source<NavigationController>(source).ptr();
-      source_tab = controller->tab_contents();
-      detail_info = Details<content::LoadCommittedDetails>(details).ptr();
+      content::LoadCommittedDetails* load_details =
+          Details<content::LoadCommittedDetails>(details).ptr();
+      OnNavEntryCommitted(controller->tab_contents(), load_details);
       break;
     }
     default: {
       NOTREACHED();
       break;
     }
   }
+}
+
+void PrintPreviewTabController::OnRendererProcessClosed(
+    RenderProcessHost* rph) {
+  TabContents* initiator_tab = NULL;
+  for (PrintPreviewTabMap::iterator iter = preview_tab_map_.begin();
+       iter != preview_tab_map_.end(); ++iter) {
+    if (iter->second->render_view_host()->process() == rph) {
+      initiator_tab = iter->second;
+      break;
+    }
+  }
 
-  DCHECK(source_tab);
+  // The Print Preview renderer crashed.
+  if (!initiator_tab)

[Lei Zhang, 2011/08/09 20:51:19]

In this case, do you need to call RemoveObservers() for the print preview tab? I
don't know if observers are automatically removed for a crashed tab.

[kmadhusu, 2011/08/10 16:46:59]

We should not remove the observers for the preview tab because when the user
navigates from/to the preview tab, we should be able to identify the preview tab
and prevent the print operation on that tab.

+    return;
 
-  TabContents* preview_tab = GetPrintPreviewForTab(source_tab);
-  bool source_tab_is_preview_tab = (source_tab == preview_tab);
+  TabContents* preview_tab = GetPrintPreviewForTab(initiator_tab);
+  PrintPreviewUI* print_preview_ui =
+      static_cast<PrintPreviewUI*>(preview_tab->web_ui());
+  print_preview_ui->OnInitiatorTabCrashed();

[Lei Zhang, 2011/08/09 20:51:19]

Do you need to check |preview_tab| or |print_preview_ui| to see if they are
NULL?

[kmadhusu, 2011/08/10 16:46:59]

They will be valid. If you want I can add a DCHECK.

+}
 
-  if (detail_info) {
-    PageTransition::Type transition_type =
-        detail_info->entry->transition_type();
-    NavigationType::Type nav_type = detail_info->type;
+void PrintPreviewTabController::OnTabContentsDestroyed(TabContents* tab) {
+  TabContents* preview_tab = GetPrintPreviewForTab(tab);
+  if (!preview_tab)
+    return;
+
+  if (tab == preview_tab) {
+    // Remove the initiator tab's observers before erasing the mapping.
+    TabContents* initiator_tab = GetInitiatorTab(tab);
+    if (initiator_tab)
+      RemoveObservers(initiator_tab);
+
+    // In the case where the user chooses to re-open the initiator tab after
+    // closing it, |tab| has navigated to the URL of the initiator tab at this
+    // point. Verify that |tab| really is a print preview tab.
+    if (IsPrintPreviewTab(tab) && tab->web_ui()) {

[Lei Zhang, 2011/08/09 20:51:19]

If the print preview tab is navigating to its initiator tab URL, shouldn't that
be handled in OnNavEntryCommitted() below?

[kmadhusu, 2011/08/10 16:46:59]

The comment is misleading. Here, the preview tab is destroyed, so we are
notifying |PrintPreviewUI| to abort the initiator tab preview requests.

Fixed the comment.

+      PrintPreviewUI* print_preview_ui =
+          static_cast<PrintPreviewUI*>(tab->web_ui());
+      print_preview_ui->OnNavigation();
+    }
+
+    // Erase the map entry.
+    preview_tab_map_.erase(tab);
+  } else {
+    // Initiator tab is closed. Disable the controls in preview tab.
+    if (preview_tab->web_ui()) {
+      PrintPreviewUI* print_preview_ui =
+          static_cast<PrintPreviewUI*>(preview_tab->web_ui());
+      print_preview_ui->OnInitiatorTabClosed();
+    }
+
+    // |tab| is an initiator tab, update the map entry and remove observers.
+    preview_tab_map_[preview_tab] = NULL;
+  }
+
+  RemoveObservers(tab);
+}
+
+void PrintPreviewTabController::OnNavEntryCommitted(
+    TabContents* tab, content::LoadCommittedDetails* details) {
+  TabContents* preview_tab = GetPrintPreviewForTab(tab);
+  bool source_tab_is_preview_tab = (tab == preview_tab);
+  if (details) {
+    PageTransition::Type transition_type = details->entry->transition_type();
+    NavigationType::Type nav_type = details->type;
 
     // Don't update/erase the map entry if the page has not changed.
     if (transition_type == PageTransition::RELOAD ||
         nav_type == NavigationType::SAME_PAGE) {
       return;
     }
 
     // New |preview_tab| is created. Don't update/erase map entry.
     if (waiting_for_new_preview_page_ &&
         transition_type == PageTransition::LINK &&
         nav_type == NavigationType::NEW_PAGE &&
         source_tab_is_preview_tab) {
       waiting_for_new_preview_page_ = false;
+      // Set the initiator tab url.
+      TabContents* initiator_tab = GetInitiatorTab(tab);
+      if (initiator_tab) {
+        if (preview_tab->web_ui()) {

[Lei Zhang, 2011/08/09 20:51:19]

nit: combine with the if statement above.

[kmadhusu, 2011/08/10 16:46:59]

Done.

+          PrintPreviewUI* print_preview_ui =
+              static_cast<PrintPreviewUI*>(preview_tab->web_ui());
+          print_preview_ui->SetInitiatorTabURL(initiator_tab->GetURL().spec());
+        }
+      }
       return;
     }
 
     // User navigated to a preview tab using forward/back button.
     if (source_tab_is_preview_tab &&
         transition_type == PageTransition::FORWARD_BACK &&
         nav_type == NavigationType::EXISTING_PAGE) {
       return;
     }
   }
 
+  RemoveObservers(tab);
   if (source_tab_is_preview_tab) {
     // Remove the initiator tab's observers before erasing the mapping.
-    TabContents* initiator_tab = GetInitiatorTab(source_tab);
+    TabContents* initiator_tab = GetInitiatorTab(tab);
     if (initiator_tab)
       RemoveObservers(initiator_tab);
+    preview_tab_map_.erase(tab);
+  } else {
+    preview_tab_map_[preview_tab] = NULL;
 
-    // |source_tab_is_preview_tab| is misleading in the case where the user
-    // chooses to re-open the initiator tab after closing it, as |source_tab|
-    // has navigated to the URL of the initiator tab at this point. Make sure to
-    // verify that |source_tab| really is a print preview tab.
-    if (IsPrintPreviewTab(source_tab) && source_tab->web_ui()) {
+    // Initiator tab is closed. Disable the controls in preview tab.
+    if (preview_tab->web_ui()) {
       PrintPreviewUI* print_preview_ui =
-          static_cast<PrintPreviewUI*>(source_tab->web_ui());
-      print_preview_ui->OnNavigation();
+          static_cast<PrintPreviewUI*>(preview_tab->web_ui());
+      print_preview_ui->OnInitiatorTabClosed();
     }
-
-    // Erase the map entry.
-    preview_tab_map_.erase(source_tab);
-  } else {
-    // Initiator tab is closed. Disable the controls in preview tab.
-    PrintPreviewUI* print_preview_ui =
-        static_cast<PrintPreviewUI*>(preview_tab->web_ui());
-    print_preview_ui->OnInitiatorTabClosed(source_tab->GetURL().spec());
-
-    // |source_tab| is an initiator tab, update the map entry.
-    preview_tab_map_[preview_tab] = NULL;
   }
-  RemoveObservers(source_tab);
 }
 
 // static
 bool PrintPreviewTabController::IsPrintPreviewTab(TabContents* tab) {
   const GURL& url = tab->GetURL();
   return (url.SchemeIs(chrome::kChromeUIScheme) &&
           url.host() == chrome::kChromeUIPrintHost);
 }
 
 void PrintPreviewTabController::EraseInitiatorTabInfo(
     TabContents* preview_tab) {
   PrintPreviewTabMap::iterator it = preview_tab_map_.find(preview_tab);
   if (it == preview_tab_map_.end())
     return;
 
   RemoveObservers(it->second);
   preview_tab_map_[preview_tab] = NULL;
 }
 
 TabContents* PrintPreviewTabController::GetInitiatorTab(
     TabContents* preview_tab) {
   PrintPreviewTabMap::iterator it = preview_tab_map_.find(preview_tab);
   if (it != preview_tab_map_.end())
     return preview_tab_map_[preview_tab];
+
   return NULL;
 }
 
 TabContents* PrintPreviewTabController::CreatePrintPreviewTab(
     TabContents* initiator_tab) {
   // TODO: this should be converted to TabContentsWrapper.
   TabContentsWrapper* tab =
       TabContentsWrapper::GetCurrentWrapperForContents(initiator_tab);
   DCHECK(tab);
   Browser* current_browser = BrowserList::FindBrowserWithID(
@@ skipping 33 matching lines @@
   AddObservers(preview_tab->tab_contents());
 
   return preview_tab->tab_contents();
 }
 
 void PrintPreviewTabController::AddObservers(TabContents* tab) {
   registrar_.Add(this, content::NOTIFICATION_TAB_CONTENTS_DESTROYED,
                  Source<TabContents>(tab));
   registrar_.Add(this, content::NOTIFICATION_NAV_ENTRY_COMMITTED,
                  Source<NavigationController>(&tab->controller()));
+
+  // Multiple sites may share the same RenderProcessHost, so check if this
+  // notification has already been added.
+  RenderProcessHost* rph = tab->render_view_host()->process();
+  if (!registrar_.IsRegistered(this,
+                               content::NOTIFICATION_RENDERER_PROCESS_CLOSED,
+                               Source<RenderProcessHost>(rph))) {
+    registrar_.Add(this, content::NOTIFICATION_RENDERER_PROCESS_CLOSED,
+                   Source<RenderProcessHost>(rph));
+  }
 }
 
 void PrintPreviewTabController::RemoveObservers(TabContents* tab) {
   registrar_.Remove(this, content::NOTIFICATION_TAB_CONTENTS_DESTROYED,
                     Source<TabContents>(tab));
   registrar_.Remove(this, content::NOTIFICATION_NAV_ENTRY_COMMITTED,
                     Source<NavigationController>(&tab->controller()));
+
+  // Multiple sites may share the same RenderProcessHost, so check if this
+  // notification has already been added.
+  RenderProcessHost* rph = tab->render_view_host()->process();
+  if (registrar_.IsRegistered(this,
+                              content::NOTIFICATION_RENDERER_PROCESS_CLOSED,
+                              Source<RenderProcessHost>(rph))) {
+    registrar_.Remove(this, content::NOTIFICATION_RENDERER_PROCESS_CLOSED,
+                      Source<RenderProcessHost>(rph));
+  }
 }
 
 }  // namespace printing