Implement print preview tab controller.

chrome/browser/printing/print_preview_tab_controller.cc

Index: chrome/browser/printing/print_preview_tab_controller.cc
diff --git a/chrome/browser/printing/print_preview_tab_controller.cc b/chrome/browser/printing/print_preview_tab_controller.cc
new file mode 100644
index 0000000000000000000000000000000000000000..e1ff85061e15a7d68ca72193f62a25988b1dda32
--- /dev/null
+++ b/chrome/browser/printing/print_preview_tab_controller.cc
@@ -0,0 +1,194 @@
+// Copyright (c) 2010 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 "chrome/browser/browser_process.h"
+#include "chrome/browser/tab_contents/tab_contents.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/common/notification_service.h"
+#include "chrome/common/url_constants.h"
+
+namespace printing {
+
+// static
+PrintPreviewTabController* PrintPreviewTabController::GetInstance() {
+  if (!g_browser_process)
+    return NULL;
+  return g_browser_process->print_preview_tab_controller();
+}
+
+PrintPreviewTabController::PrintPreviewTabController()
+    : waiting_for_new_preview_page_(false) {
+}
+
+PrintPreviewTabController::~PrintPreviewTabController() {
+  preview_tab_map_.clear();
+}
+
+TabContents* PrintPreviewTabController::GetOrCreatePreviewTab(
+    TabContents* initiator_tab, int browser_window_id ) {

[Lei Zhang, 2010/11/13 05:04:56]

The current implementation of IsPrintPreviewTab() below assumes the tab you pass
in here, |initiator_tab|, is not NULL. Add a DCHECK?

[kmadhusu, 2010/11/15 21:22:27]

Done.

+  // Initiator tab is a preview tab.
+  if (IsPrintPreviewTab(initiator_tab))
+    return initiator_tab;
+
+  // Get the preview tab for initiator tab.
+  TabContents* preview_tab = GetPreviewTab(initiator_tab);
+  if (preview_tab) {
+    // Show current preview tab.
+    preview_tab->Activate();
+    return preview_tab;
+  }
+  return CreatePrintPreviewTab(initiator_tab, browser_window_id);
+}
+
+bool PrintPreviewTabController::IsPrintPreviewTab(TabContents* tab) {
+  const GURL& url = tab->GetURL();

[Lei Zhang, 2010/11/13 05:04:56]

If you already have a mapping of print preview tabs to initiator tabs, why do
you also have this check?

[kmadhusu, 2010/11/15 21:22:27]

I need this check because we can navigate to a preview tab by forward/back
button. At that time, we dont have an entry in the preview_tab_map_ to check
for. 

+  if (url.SchemeIs(chrome::kChromeUIScheme) &&
+      url.host() == chrome::kChromeUIPrintHost)
+    return true;
+
+  TabContents* preview_tab = GetPreviewTab(tab);
+  return ((preview_tab)? (preview_tab == tab) : false);

[Lei Zhang, 2010/11/13 05:04:56]

nit: you don't need the outer most parenthesis and the set around |preview_tab|
on the left. Add a space before '?'.

[kmadhusu, 2010/11/15 21:22:27]

Previous check is sufficient to identify a preview tab. I am removing this code.

+}
+
+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::GetPreviewTab(
+    TabContents* current_tab) {
+  for (PrintPreviewTabMap::iterator it = preview_tab_map_.begin();
+       it != preview_tab_map_.end(); ++it) {
+    if ((it->second == current_tab) || (it->first == current_tab))

[Lei Zhang, 2010/11/13 05:04:56]

if you first do preview_tab_map_.find(current_tab) and handle that case, you
don't need to check it->first here.

[kmadhusu, 2010/11/15 21:22:27]

To my understanding, "find(key)" function is used to find whether an entry exist
in the map with the specified key. Here I am trying to check whether the
|current_tab| is either key or value of a map entry. So, I am using for loop to
check for both cases.  

[Lei Zhang, 2010/11/16 00:47:39]

If preview_tab_map_.find(current_tab) returns preview_tab_map_.end(), then you
know |current_tab| does not exist as a key, so you can just check to see if it's
a value in the map.

+      return it->first;
+  }
+  return NULL;
+}
+
+void PrintPreviewTabController::AddObservers(TabContents* tab) {
+  registrar_.Add(this, NotificationType::TAB_CONTENTS_DESTROYED,
+                 Source<TabContents>(tab));
+  registrar_.Add(this, NotificationType::NAV_ENTRY_COMMITTED,
+                 Source<NavigationController>(&tab->controller()));
+}
+
+void PrintPreviewTabController::RemoveObservers(TabContents* tab) {
+  registrar_.Remove(this, NotificationType::TAB_CONTENTS_DESTROYED,
+                    Source<TabContents>(tab));
+  registrar_.Remove(this, NotificationType::NAV_ENTRY_COMMITTED,
+                    Source<NavigationController>(&tab->controller()));
+}
+
+TabContents* PrintPreviewTabController::CreatePrintPreviewTab(
+    TabContents* initiator_tab, int browser_window_id) {
+  Browser* current_browser = BrowserList::FindBrowserWithID(browser_window_id);
+  // Add a new tab next to initiator tab.
+  browser::NavigateParams params(current_browser,
+                                 GURL(chrome::kChromeUIPrintURL),
+                                 PageTransition::LINK);
+  params.disposition = NEW_FOREGROUND_TAB;
+  params.tabstrip_index = current_browser->tabstrip_model()->
+      GetIndexOfTabContents(initiator_tab) + 1;
+  browser::Navigate(&params);
+  TabContents* preview_tab = params.target_contents;
+  preview_tab->Activate();
+
+  // Add an entry to the map.
+  preview_tab_map_[preview_tab] = initiator_tab;
+  waiting_for_new_preview_page_ = true;
+
+  AddObservers(initiator_tab);
+  AddObservers(preview_tab);
+
+  return preview_tab;
+}
+
+void PrintPreviewTabController::Observe(NotificationType type,
+                                        const NotificationSource& source,
+                                        const NotificationDetails& details) {
+  TabContents* initiator_tab = NULL;
+  TabContents* preview_tab = NULL;
+  TabContents* source_tab = NULL;
+  NavigationController::LoadCommittedDetails* detail_info = NULL;
+
+  switch (type.value) {
+    case NotificationType::TAB_CONTENTS_DESTROYED: {
+      source_tab = Source<TabContents>(source).ptr();
+      break;
+    }
+    case NotificationType::NAV_ENTRY_COMMITTED: {
+      NavigationController* controller =
+          Source<NavigationController>(source).ptr();
+      source_tab = controller->tab_contents();
+      detail_info =
+          Details<NavigationController::LoadCommittedDetails>(details).ptr();
+      break;
+    }
+    default: {
+      NOTREACHED();
+      return;
+    }
+  }
+
+  if (IsPrintPreviewTab(source_tab)) {
+    // |source_tab| is preview tab.
+    initiator_tab = GetInitiatorTab(source_tab);
+    preview_tab = source_tab;
+  } else {
+    initiator_tab = source_tab;
+    preview_tab = GetPreviewTab(source_tab);
+  }
+
+  if (detail_info) {
+    PageTransition::Type transition_type =
+        detail_info->entry->transition_type();
+    NavigationType::Type nav_type = detail_info->type;
+
+    // Don't update/erase the map entry if the page has not changed.
+    bool reload = (transition_type == PageTransition::RELOAD ||

[Lei Zhang, 2010/11/13 05:04:56]

nit: no need for |reload| and other variables below since they are only used
once, immediately after they get assigned.

[kmadhusu, 2010/11/15 21:22:27]

Done.

+                   nav_type == NavigationType::SAME_PAGE);
+    if (reload)
+      return;
+
+    // New |preview_tab| is created. Don't update/erase map entry.
+    bool is_preview_tab_loaded = (transition_type == PageTransition::LINK &&
+                                  nav_type == NavigationType::NEW_PAGE &&
+                                  source_tab == preview_tab);
+    if (waiting_for_new_preview_page_ && is_preview_tab_loaded) {
+      waiting_for_new_preview_page_ = false;
+      return;
+    }
+
+    // User navigated to existing |preview_tab| using forward/back button.
+    bool nav_to_prev_tab = (IsPrintPreviewTab(source_tab) &&
+                            transition_type == PageTransition::FORWARD_BACK &&
+                            nav_type == NavigationType::EXISTING_PAGE);
+    if (nav_to_prev_tab)
+      return;
+  }
+
+  // If |source_tab| is |initiator_tab|, update the map entry.
+  if (source_tab == initiator_tab) {
+    preview_tab_map_[preview_tab] = NULL;
+  }
+
+  // If |source_tab| is |preview_tab|, erase the map entry.
+  if (source_tab == preview_tab) {
+    preview_tab_map_.erase(preview_tab);
+    RemoveObservers(preview_tab);
+  }
+
+  if (initiator_tab)
+    RemoveObservers(initiator_tab);
+}
+
+} // namespace printing