Block printing through JS when printing is disabled by policy or pref

chrome/browser/printing/print_view_manager.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_view_manager.h"
 
 #include <map>
 
 #include "base/bind.h"
 #include "base/lazy_instance.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/timer.h"
 #include "base/utf_string_conversions.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/printing/print_error_dialog.h"
 #include "chrome/browser/printing/print_job.h"
 #include "chrome/browser/printing/print_job_manager.h"
 #include "chrome/browser/printing/print_preview_tab_controller.h"
 #include "chrome/browser/printing/print_view_manager_observer.h"
 #include "chrome/browser/printing/printer_query.h"
+#include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/ui/tab_contents/tab_contents.h"
 #include "chrome/browser/ui/webui/print_preview/print_preview_ui.h"
 #include "chrome/common/chrome_notification_types.h"
+#include "chrome/common/pref_names.h"
 #include "chrome/common/print_messages.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/notification_details.h"
 #include "content/public/browser/notification_service.h"
 #include "content/public/browser/notification_source.h"
 #include "content/public/browser/render_view_host.h"
 #include "content/public/browser/web_contents.h"
 #include "content/public/browser/web_contents_view.h"
 #include "grit/generated_resources.h"
 #include "printing/metafile.h"
 #include "printing/metafile_impl.h"
 #include "printing/print_destination_interface.h"
 #include "printing/printed_document.h"
 #include "ui/base/l10n/l10n_util.h"
 
 using base::TimeDelta;
 using content::BrowserThread;
-using content::RenderViewHost;
 
 namespace {
 
 // Keeps track of pending scripted print preview closures.
 // No locking, only access on the UI thread.
 typedef std::map<content::RenderProcessHost*, base::Closure>
     ScriptedPrintPreviewClosureMap;
 static base::LazyInstance<ScriptedPrintPreviewClosureMap>
     g_scripted_print_preview_closure_map = LAZY_INSTANCE_INITIALIZER;
 
 }  // namespace
 
 namespace printing {
 
 PrintViewManager::PrintViewManager(TabContents* tab)
     : content::WebContentsObserver(tab->web_contents()),
       tab_(tab),
       number_pages_(0),
       printing_succeeded_(false),
       inside_inner_message_loop_(false),
       observer_(NULL),
       cookie_(0),
       print_preview_state_(NOT_PREVIEWING),
-      scripted_print_preview_rph_(NULL) {
+      scripted_print_preview_rph_(NULL),
+      tab_content_blocked_(false) {
 #if defined(OS_POSIX) && !defined(OS_MACOSX)
   expecting_first_page_ = true;
 #endif
   registrar_.Add(this, chrome::NOTIFICATION_CONTENT_BLOCKED_STATE_CHANGED,
                  content::Source<TabContents>(tab));
+  printing_enabled_.Init(prefs::kPrintingEnabled,
+                         tab->profile()->GetPrefs(),
+                         this);
 }
 
 PrintViewManager::~PrintViewManager() {
   DCHECK_EQ(NOT_PREVIEWING, print_preview_state_);
   ReleasePrinterQuery();
   DisconnectFromCurrentPrintJob();
 }
 
 bool PrintViewManager::PrintNow() {
   return PrintNowInternal(new PrintMsg_PrintPages(routing_id()));
@@ skipping 56 matching lines @@
     ScriptedPrintPreviewClosureMap::iterator it =
         map.find(scripted_print_preview_rph_);
     CHECK(it != map.end());
     it->second.Run();
     map.erase(scripted_print_preview_rph_);
     scripted_print_preview_rph_ = NULL;
   }
   print_preview_state_ = NOT_PREVIEWING;
 }
 
-void PrintViewManager::SetScriptedPrintingBlocked(bool blocked) {
-  Send(new PrintMsg_SetScriptedPrintingBlocked(routing_id(), blocked));
+void PrintViewManager::UpdateScriptedPrintingBlocked() {
+  Send(new PrintMsg_SetScriptedPrintingBlocked(
+       routing_id(),
+       !printing_enabled_.GetValue() || tab_content_blocked_));
 }
 
 void PrintViewManager::set_observer(PrintViewManagerObserver* observer) {
   DCHECK(!observer || !observer_);
   observer_ = observer;
 }
 
 void PrintViewManager::StopNavigation() {
   // Cancel the current job, wait for the worker to finish.
   TerminatePrintJob(true);
@@ skipping 154 matching lines @@
   PrintPreviewUI::SetSourceIsModifiable(
       tab_controller->GetPrintPreviewForTab(tab_),
       source_is_modifiable);
 }
 
 void PrintViewManager::OnScriptedPrintPreviewReply(IPC::Message* reply_msg) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   Send(reply_msg);
 }
 
+void PrintViewManager::DidStartLoading(
+    content::RenderViewHost* render_view_host) {
+  UpdateScriptedPrintingBlocked();
+}
+
 bool PrintViewManager::OnMessageReceived(const IPC::Message& message) {
   bool handled = true;
   IPC_BEGIN_MESSAGE_MAP(PrintViewManager, message)
     IPC_MESSAGE_HANDLER(PrintHostMsg_DidGetPrintedPagesCount,
                         OnDidGetPrintedPagesCount)
     IPC_MESSAGE_HANDLER(PrintHostMsg_DidGetDocumentCookie,
                         OnDidGetDocumentCookie)
     IPC_MESSAGE_HANDLER(PrintHostMsg_DidShowPrintDialog, OnDidShowPrintDialog)
     IPC_MESSAGE_HANDLER(PrintHostMsg_DidPrintPage, OnDidPrintPage)
     IPC_MESSAGE_HANDLER(PrintHostMsg_PrintingFailed, OnPrintingFailed)
     IPC_MESSAGE_HANDLER_DELAY_REPLY(PrintHostMsg_ScriptedPrintPreview,
                                     OnScriptedPrintPreview)
     IPC_MESSAGE_UNHANDLED(handled = false)
   IPC_END_MESSAGE_MAP()
   return handled;
 }
 
 void PrintViewManager::Observe(int type,
                                const content::NotificationSource& source,
                                const content::NotificationDetails& details) {
   switch (type) {
     case chrome::NOTIFICATION_PRINT_JOB_EVENT: {
       OnNotifyPrintJobEvent(*content::Details<JobEventDetails>(details).ptr());
       break;
     }
+    case chrome::NOTIFICATION_PREF_CHANGED: {
+      UpdateScriptedPrintingBlocked();
+      break;
+    }
     case chrome::NOTIFICATION_CONTENT_BLOCKED_STATE_CHANGED: {
-      SetScriptedPrintingBlocked(*content::Details<const bool>(details).ptr());
+      tab_content_blocked_ = *content::Details<const bool>(details).ptr();
+      UpdateScriptedPrintingBlocked();
       break;
     }
     default: {
       NOTREACHED();
       break;
     }
   }
 }
 
 void PrintViewManager::OnNotifyPrintJobEvent(
@@ skipping 274 matching lines @@
   scoped_refptr<printing::PrinterQuery> printer_query;
   print_job_manager->PopPrinterQuery(cookie, &printer_query);
   if (!printer_query.get())
     return;
   BrowserThread::PostTask(
       BrowserThread::IO, FROM_HERE,
       base::Bind(&PrinterQuery::StopWorker, printer_query.get()));
 }
 
 }  // namespace printing