PrintPreview: Added new histograms for print preview.

chrome/browser/ui/webui/print_preview_handler.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/ui/webui/print_preview_handler.h"
 
 #include <string>
 
 #include "base/i18n/file_util_icu.h"
 #include "base/json/json_reader.h"
+#include "base/metrics/histogram.h"
 #include "base/path_service.h"
 #include "base/threading/thread.h"
 #include "base/threading/thread_restrictions.h"
 #include "base/utf_string_conversions.h"
 #include "base/values.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/platform_util.h"
 #include "chrome/browser/printing/background_printing_manager.h"
 #include "chrome/browser/printing/printer_manager_dialog.h"
 #include "chrome/browser/printing/print_preview_tab_controller.h"
@@ skipping 59 matching lines @@
   return settings.release();
 }
 
 }  // namespace
 
 class PrintSystemTaskProxy
     : public base::RefCountedThreadSafe<PrintSystemTaskProxy,
                                         BrowserThread::DeleteOnUIThread> {
  public:
   PrintSystemTaskProxy(const base::WeakPtr<PrintPreviewHandler>& handler,
-                             printing::PrintBackend* print_backend)
+                       printing::PrintBackend* print_backend,
+                       bool has_logged_printers_count)
       : handler_(handler),
-        print_backend_(print_backend) {
+        print_backend_(print_backend),
+        has_logged_printers_count_(has_logged_printers_count) {
   }
 
   void EnumeratePrinters() {
     ListValue* printers = new ListValue;
     int default_printer_index = -1;
 
     printing::PrinterList printer_list;
     print_backend_->EnumeratePrinters(&printer_list);
+
+    if (!has_logged_printers_count_) {
+      // Record the total number of printers.
+      UMA_HISTOGRAM_COUNTS("PrintPreview.NumberOfPrinters",
+                           printer_list.size());
+    }
+
     int i = 0;
     for (printing::PrinterList::iterator index = printer_list.begin();
          index != printer_list.end(); ++index, ++i) {
       DictionaryValue* printer_info = new DictionaryValue;
       std::string printerName;
   #if defined(OS_MACOSX)
       // On Mac, |index->printer_description| specifies the printer name and
       // |index->printer_name| specifies the device name / printer queue name.
       printerName = index->printer_description;
   #else
@@ skipping 83 matching lines @@
  private:
   friend struct BrowserThread::DeleteOnThread<BrowserThread::UI>;
   friend class DeleteTask<PrintSystemTaskProxy>;
 
   ~PrintSystemTaskProxy() {}
 
   base::WeakPtr<PrintPreviewHandler> handler_;
 
   scoped_refptr<printing::PrintBackend> print_backend_;
 
+  bool has_logged_printers_count_;
+
   DISALLOW_COPY_AND_ASSIGN(PrintSystemTaskProxy);
 };
 
 // A Task implementation that stores a PDF file on disk.
 class PrintToPdfTask : public Task {
  public:
   // Takes ownership of |metafile|.
   PrintToPdfTask(printing::Metafile* metafile, const FilePath& path)
       : metafile_(metafile), path_(path) {
     DCHECK(metafile);
@@ skipping 15 matching lines @@
   scoped_ptr<printing::Metafile> metafile_;
 
   // The absolute path where the file will be saved.
   FilePath path_;
 };
 
 // static
 FilePath* PrintPreviewHandler::last_saved_path_ = NULL;
 
 PrintPreviewHandler::PrintPreviewHandler()
-    : print_backend_(printing::PrintBackend::CreateInstance(NULL)) {
+    : print_backend_(printing::PrintBackend::CreateInstance(NULL)),
+      regenerate_preview_request_count_(0),
+      manage_printers_dialog_request_count_(0),
+      print_preview_failed_count_(0),
+      has_logged_printers_count_(false) {
 }
 
 PrintPreviewHandler::~PrintPreviewHandler() {
   if (select_file_dialog_.get())
     select_file_dialog_->ListenerDestroyed();
 }
 
 void PrintPreviewHandler::RegisterMessages() {
   web_ui_->RegisterMessageCallback("getPrinters",
       NewCallback(this, &PrintPreviewHandler::HandleGetPrinters));
@@ skipping 10 matching lines @@
   web_ui_->RegisterMessageCallback("closePrintPreviewTab",
       NewCallback(this, &PrintPreviewHandler::HandleClosePreviewTab));
 }
 
 TabContents* PrintPreviewHandler::preview_tab() {
   return web_ui_->tab_contents();
 }
 
 void PrintPreviewHandler::HandleGetPrinters(const ListValue*) {
   scoped_refptr<PrintSystemTaskProxy> task =
-      new PrintSystemTaskProxy(AsWeakPtr(), print_backend_.get());
+      new PrintSystemTaskProxy(AsWeakPtr(),
+                               print_backend_.get(),
+                               has_logged_printers_count_);
+  if (!has_logged_printers_count_)

[Lei Zhang, 2011/05/17 00:09:38]

nit: you don't need the if statement. The branching is likely more expensive
than just setting the bit.

[kmadhusu, 2011/05/17 00:22:09]

Done.

+    has_logged_printers_count_ = true;
+
   BrowserThread::PostTask(
       BrowserThread::FILE, FROM_HERE,
       NewRunnableMethod(task.get(),
                         &PrintSystemTaskProxy::EnumeratePrinters));
 }
 
 void PrintPreviewHandler::HandleGetPreview(const ListValue* args) {
+  // Increment request count.
+  ++regenerate_preview_request_count_;
+
   TabContents* initiator_tab = GetInitiatorTab();
   if (!initiator_tab) {
+    ++print_preview_failed_count_;
     web_ui_->CallJavascriptFunction("printPreviewFailed");
     return;
   }
   scoped_ptr<DictionaryValue> settings(GetSettingsDictionary(args));
   if (!settings.get())
     return;
 
   RenderViewHost* rvh = initiator_tab->render_view_host();
   rvh->Send(new PrintMsg_PrintPreview(rvh->routing_id(), *settings));
 }
 
 void PrintPreviewHandler::HandlePrint(const ListValue* args) {
+  ReportStats();
+  UMA_HISTOGRAM_COUNTS("PrintPreview.Print", 1);
+
+  // Record the number of times the user requests to regenerate preview data
+  // before printing.
+  UMA_HISTOGRAM_COUNTS(
+      "PrintPreview.RegeneratePreviewRequest.BeforePrint",
+      regenerate_preview_request_count_);
+
   TabContents* initiator_tab = GetInitiatorTab();
   if (initiator_tab) {
     RenderViewHost* rvh = initiator_tab->render_view_host();
     rvh->Send(new PrintMsg_ResetScriptedPrintCount(rvh->routing_id()));
   }
 
   scoped_ptr<DictionaryValue> settings(GetSettingsDictionary(args));
   if (!settings.get())
     return;
 
   bool print_to_pdf = false;
   settings->GetBoolean(printing::kSettingPrintToPDF, &print_to_pdf);
 
   TabContentsWrapper* preview_tab_wrapper =
       TabContentsWrapper::GetCurrentWrapperForContents(preview_tab());
 
   if (print_to_pdf) {
+    UMA_HISTOGRAM_COUNTS("PrintPreview.PrintToPDF", 1);
+
     // Pre-populating select file dialog with print job title.
     string16 print_job_title_utf16 =
         preview_tab_wrapper->print_view_manager()->RenderSourceName();
 
 #if defined(OS_WIN)
     FilePath::StringType print_job_title(print_job_title_utf16);
 #elif defined(OS_POSIX)
     FilePath::StringType print_job_title = UTF16ToUTF8(print_job_title_utf16);
 #endif
 
@@ skipping 16 matching lines @@
 }
 
 void PrintPreviewHandler::HandleGetPrinterCapabilities(
     const ListValue* args) {
   std::string printer_name;
   bool ret = args->GetString(0, &printer_name);
   if (!ret || printer_name.empty())
     return;
 
   scoped_refptr<PrintSystemTaskProxy> task =
-      new PrintSystemTaskProxy(AsWeakPtr(), print_backend_.get());
+      new PrintSystemTaskProxy(AsWeakPtr(),
+                               print_backend_.get(),
+                               has_logged_printers_count_);
 
   BrowserThread::PostTask(
       BrowserThread::FILE, FROM_HERE,
       NewRunnableMethod(task.get(),
                         &PrintSystemTaskProxy::GetPrinterCapabilities,
                         printer_name));
 }
 
 void PrintPreviewHandler::HandleShowSystemDialog(const ListValue* args) {
+  ReportStats();
+  UMA_HISTOGRAM_COUNTS("PrintPreview.ShowAdvanceSettings", 1);
   TabContents* initiator_tab = GetInitiatorTab();
   if (!initiator_tab)
     return;
   initiator_tab->Activate();
 
   TabContentsWrapper* wrapper =
       TabContentsWrapper::GetCurrentWrapperForContents(initiator_tab);
   wrapper->print_view_manager()->PrintNow();
 
   ClosePrintPreviewTab();
 }
 
 void PrintPreviewHandler::HandleManagePrinters(const ListValue* args) {
+  ++manage_printers_dialog_request_count_;
   printing::PrinterManagerDialog::ShowPrinterManagerDialog();
 }
 
 void PrintPreviewHandler::HandleClosePreviewTab(const ListValue* args) {
+  ReportStats();
+  UMA_HISTOGRAM_COUNTS("PrintPreview.Cancel", 1);
+
+  // Record the number of times the user requests to regenerate preview data
+  // before cancelling.
+  UMA_HISTOGRAM_COUNTS(
+      "PrintPreview.RegeneratePreviewRequest.BeforeCancel",
+      regenerate_preview_request_count_);
+
   ActivateInitiatorTabAndClosePreviewTab();
 }
 
+void PrintPreviewHandler::ReportStats() {
+  if (print_preview_failed_count_ > 0) {
+    UMA_HISTOGRAM_COUNTS("PrintPreview.Failed.InitiatorTabDoesNotExist",
+                         print_preview_failed_count_);
+  }
+
+  UMA_HISTOGRAM_COUNTS("PrintPreview.ManagePrinters",
+                       manage_printers_dialog_request_count_);
+}
+
 void PrintPreviewHandler::ActivateInitiatorTabAndClosePreviewTab() {
   TabContents* initiator_tab = GetInitiatorTab();
   if (initiator_tab)
     initiator_tab->Activate();
   ClosePrintPreviewTab();
 }
 
 void PrintPreviewHandler::SendPrinterCapabilities(
     const DictionaryValue& settings_info) {
   web_ui_->CallJavascriptFunction("updateWithPrinterCapabilities",
@@ skipping 68 matching lines @@
   metafile->InitFromData(data.first->memory(), data.second);
 
   // Updating last_saved_path_ to the newly selected folder.
   *last_saved_path_ = path.DirName();
 
   PrintToPdfTask* task = new PrintToPdfTask(metafile, path);
   BrowserThread::PostTask(BrowserThread::FILE, FROM_HERE, task);
 
   ActivateInitiatorTabAndClosePreviewTab();
 }