Add additional stats for print preview.

chrome/browser/ui/webui/print_preview/print_preview_handler.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/ui/webui/print_preview/print_preview_handler.h"
 
 #include <ctype.h>
 
 #include <string>
 #include <vector>
@@ skipping 77 matching lines @@
   LANDSCAPE,
   PORTRAIT,
   COLOR,
   BLACK_AND_WHITE,
   COLLATE,
   SIMPLEX,
   DUPLEX,
   PRINT_SETTINGS_BUCKET_BOUNDARY
 };
 
+enum PrintDestinationBuckets {
+  DESTINATION_SHOWN,
+  DESTINATION_CLOSED_CHANGED,
+  DESTINATION_CLOSED_UNCHANGED,
+  SIGNIN_PROMPT,
+  SIGNIN_TRIGGERED,
+  PRINT_DESTINATION_BUCKET_BOUNDARY
+};
+
 void ReportUserActionHistogram(enum UserActionBuckets event) {
   UMA_HISTOGRAM_ENUMERATION("PrintPreview.UserAction", event,
                             USERACTION_BUCKET_BOUNDARY);
 }
 
 void ReportPrintSettingHistogram(enum PrintSettingsBuckets setting) {
   UMA_HISTOGRAM_ENUMERATION("PrintPreview.PrintSettings", setting,
                             PRINT_SETTINGS_BUCKET_BOUNDARY);
 }
 
+void ReportPrintDestinationHistogram(enum PrintDestinationBuckets event) {
+  UMA_HISTOGRAM_ENUMERATION("PrintPreview.DestinationAction", event,
+                            PRINT_DESTINATION_BUCKET_BOUNDARY);
+}
+
 // Name of a dictionary fielad holdong cloud print related data;
 const char kCloudPrintData[] = "cloudPrintData";
 // Name of a dictionary field holding the initiator tab title.
 const char kInitiatorTabTitle[] = "initiatorTabTitle";
 // Name of a dictionary field holding the measurement system according to the
 // locale.
 const char kMeasurementSystem[] = "measurementSystem";
 // Name of a dictionary field holding the number format according to the locale.
 const char kNumberFormat[] = "numberFormat";
 // Name of a dictionary field specifying whether to print automatically in
@@ skipping 85 matching lines @@
 
 // static
 printing::StickySettings* PrintPreviewHandler::GetStickySettings() {
   return sticky_settings.Pointer();
 }
 
 PrintPreviewHandler::PrintPreviewHandler()
     : print_backend_(printing::PrintBackend::CreateInstance(NULL)),
       regenerate_preview_request_count_(0),
       manage_printers_dialog_request_count_(0),
+      manage_cloud_printers_dialog_request_count_(0),
       reported_failed_preview_(false),
       has_logged_printers_count_(false) {
   ReportUserActionHistogram(PREVIEW_STARTED);
 }
 
 PrintPreviewHandler::~PrintPreviewHandler() {
   if (select_file_dialog_.get())
     select_file_dialog_->ListenerDestroyed();
 }
 
@@ skipping 30 matching lines @@
                  base::Unretained(this)));
   web_ui()->RegisterMessageCallback("cancelPendingPrintRequest",
       base::Bind(&PrintPreviewHandler::HandleCancelPendingPrintRequest,
                  base::Unretained(this)));
   web_ui()->RegisterMessageCallback("saveLastPrinter",
       base::Bind(&PrintPreviewHandler::HandleSaveLastPrinter,
                  base::Unretained(this)));
   web_ui()->RegisterMessageCallback("getInitialSettings",
       base::Bind(&PrintPreviewHandler::HandleGetInitialSettings,
                  base::Unretained(this)));
+  web_ui()->RegisterMessageCallback("reportDestinationEvent",
+      base::Bind(&PrintPreviewHandler::HandleReportDestinationEvent,
+                 base::Unretained(this)));
 }
 
 TabContentsWrapper* PrintPreviewHandler::preview_tab_wrapper() const {
   return TabContentsWrapper::GetCurrentWrapperForContents(preview_tab());
 }
 
 WebContents* PrintPreviewHandler::preview_tab() const {
   return web_ui()->GetWebContents();
 }
 
@@ skipping 256 matching lines @@
 
 void PrintPreviewHandler::HandleSignin(const ListValue* /*args*/) {
   print_dialog_cloud::CreateCloudPrintSigninDialog(
       base::Bind(&PrintPreviewHandler::OnSigninComplete, AsWeakPtr()));
 }
 
 void PrintPreviewHandler::HandlePrintWithCloudPrint() {
   // Record the number of times the user asks to print via cloud print
   // instead of the print preview dialog.
   ReportStats();
-  ReportUserActionHistogram(PRINT_WITH_CLOUD_PRINT);
 
   PrintPreviewUI* print_preview_ui = static_cast<PrintPreviewUI*>(
       web_ui()->GetController());
   scoped_refptr<base::RefCountedBytes> data;
   print_preview_ui->GetPrintPreviewDataForIndex(
       printing::COMPLETE_PREVIEW_DOCUMENT_INDEX, &data);
   if (!data.get()) {
     NOTREACHED();
     return;
   }
   DCHECK_GT(data->size(), 0U);
   print_dialog_cloud::CreatePrintDialogForBytes(data,
       string16(print_preview_ui->initiator_tab_title()),
       string16(),
       std::string("application/pdf"),
       true);
 
   // Once the cloud print dialog comes up we're no longer in a background
   // printing situation.  Close the print preview.
   // TODO(abodenha@chromium.org) The flow should be changed as described in
   // http://code.google.com/p/chromium/issues/detail?id=44093
   ActivateInitiatorTabAndClosePreviewTab();
 }
 
 void PrintPreviewHandler::HandleManageCloudPrint(const ListValue* /*args*/) {
+  ++manage_cloud_printers_dialog_request_count_;
   Browser* browser = BrowserList::GetLastActive();
   if (browser != NULL)
     browser->OpenURL(OpenURLParams(
         CloudPrintURL(browser->profile()).GetCloudPrintServiceManageURL(),
         Referrer(),
         NEW_FOREGROUND_TAB,
         content::PAGE_TRANSITION_LINK,
         false));
 }
 
@@ skipping 26 matching lines @@
 
   // Record the number of times the user requests to regenerate preview data
   // before cancelling.
   UMA_HISTOGRAM_COUNTS("PrintPreview.RegeneratePreviewRequest.BeforeCancel",
                        regenerate_preview_request_count_);
 }
 
 void PrintPreviewHandler::ReportStats() {
   UMA_HISTOGRAM_COUNTS("PrintPreview.ManagePrinters",
                        manage_printers_dialog_request_count_);
+  UMA_HISTOGRAM_COUNTS("PrintPreview.ManageCloudPrinters",
+                       manage_cloud_printers_dialog_request_count_);
 }
 
 void PrintPreviewHandler::GetNumberFormatAndMeasurementSystem(
     base::DictionaryValue* settings) {
 
   // Getting the measurement system based on the locale.
   UErrorCode errorCode = U_ZERO_ERROR;
   const char* locale = g_browser_process->GetApplicationLocale().c_str();
   UMeasurementSystem system = ulocdata_getMeasurementSystem(locale, &errorCode);
   if (errorCode > U_ZERO_ERROR || system == UMS_LIMIT)
     system = UMS_SI;
 
   // Getting the number formatting based on the locale and writing to
   // dictionary.
   settings->SetString(kNumberFormat, base::FormatDouble(123456.78, 2));
   settings->SetInteger(kMeasurementSystem, system);
 }
 
 void PrintPreviewHandler::HandleGetInitialSettings(const ListValue* /*args*/) {
   scoped_refptr<PrintSystemTaskProxy> task =
       new PrintSystemTaskProxy(AsWeakPtr(),
                                print_backend_.get(),
                                has_logged_printers_count_);
   BrowserThread::PostTask(
       BrowserThread::FILE, FROM_HERE,
       base::Bind(&PrintSystemTaskProxy::GetDefaultPrinter, task.get()));
 }
 
+void PrintPreviewHandler::HandleReportDestinationEvent(const ListValue* args) {
+  int event_number;
+  bool ret = args->GetInteger(0, &event_number);
+  if (!ret)
+    return;
+  enum PrintDestinationBuckets event =
+      static_cast<enum PrintDestinationBuckets>(event_number);
+  if (event >= PRINT_DESTINATION_BUCKET_BOUNDARY)
+    return;
+  ReportPrintDestinationHistogram(event);
+}
+
 void PrintPreviewHandler::SendInitialSettings(
     const std::string& default_printer,
     const std::string& cloud_print_data) {
   PrintPreviewUI* print_preview_ui = static_cast<PrintPreviewUI*>(
       web_ui()->GetController());
 
   base::DictionaryValue initial_settings;
   initial_settings.SetString(kInitiatorTabTitle,
                              print_preview_ui->initiator_tab_title());
   initial_settings.SetBoolean(printing::kSettingPreviewModifiable,
@@ skipping 53 matching lines @@
     if (prefs->GetBoolean(prefs::kCloudPrintSubmitEnabled)) {
       GURL gcp_url(CloudPrintURL(profile).GetCloudPrintServiceURL());
       base::StringValue gcp_url_value(gcp_url.spec());
       web_ui()->CallJavascriptFunction("setUseCloudPrint", gcp_url_value);
     }
   }
 }
 
 void PrintPreviewHandler::SendCloudPrintJob(const DictionaryValue& settings,
                                             std::string print_ticket) {
+  ReportUserActionHistogram(PRINT_WITH_CLOUD_PRINT);
   scoped_refptr<base::RefCountedBytes> data;
   PrintPreviewUI* print_preview_ui = static_cast<PrintPreviewUI*>(
       web_ui()->GetController());
   print_preview_ui->GetPrintPreviewDataForIndex(
       printing::COMPLETE_PREVIEW_DOCUMENT_INDEX, &data);
   if (data.get() && data->size() > 0U && data->front()) {
     string16 print_job_title_utf16 =
         preview_tab_wrapper()->print_view_manager()->RenderSourceName();
     std::string print_job_title = UTF16ToUTF8(print_job_title_utf16);
     std::string printer_id;
@@ skipping 148 matching lines @@
     return;
 
   // We no longer require the initiator tab details. Remove those details
   // associated with the preview tab to allow the initiator tab to create
   // another preview tab.
   printing::PrintPreviewTabController* tab_controller =
       printing::PrintPreviewTabController::GetInstance();
   if (tab_controller)
     tab_controller->EraseInitiatorTabInfo(preview_tab_wrapper());
 }