Bring the feedback button to the Mac sad tab

chrome/browser/ui/sad_tab.cc

 // Copyright 2013 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 "build/build_config.h"
+#include "base/metrics/histogram_macros.h"
+#include "chrome/browser/net/referrer.h"
+#include "chrome/browser/ui/browser_finder.h"
+#include "chrome/browser/ui/chrome_pages.h"
 #include "chrome/browser/ui/sad_tab.h"
+#include "chrome/common/url_constants.h"
+#include "chrome/grit/generated_resources.h"
+#include "components/feedback/feedback_util.h"
+#include "components/strings/grit/components_strings.h"
+#include "content/public/browser/navigation_controller.h"
+#include "content/public/browser/web_contents.h"
+#include "ui/base/l10n/l10n_util.h"
+
+#if defined(OS_CHROMEOS)
+#include "chrome/browser/memory/oom_memory_details.h"
+#endif
+
+namespace {
+
+// They use the same counting approach and bucket sizes as the tab discard
+// events in memory::OomPriorityManager so they can be directly compared.
+
+// TODO(jamescook): Maybe track time between sad tabs?
+
+// This macro uses a a static counter to add to the next numbered bucket each
+// time it's hit, to keep track of how many sad tabs of a given kind users see
+// per session. For details, see Tabs.SadTab.CrashCreated in histograms.xml.
+#define UMA_SAD_TAB_COUNTER(NAME)                          \
+  {                                                        \
+    static int count = 0;                                  \
+    ++count;                                               \
+    UMA_HISTOGRAM_COUNTS_1000("Tabs.SadTab." NAME, count); \
+  }
+
+// This enum backs a UMA histogram, so it should be treated as append-only.
+enum class SadTabEvent {
+  DISPLAYED,
+  BUTTON_CLICKED,
+  HELP_LINK_CLICKED,
+  MAX_SAD_TAB_EVENT
+};
+
+void RecordEvent(bool feedback, SadTabEvent event) {
+  if (feedback) {
+    UMA_HISTOGRAM_ENUMERATION("Tabs.SadTab.StyleFeedback", event,
+                              SadTabEvent::MAX_SAD_TAB_EVENT);
+  } else {
+    UMA_HISTOGRAM_ENUMERATION("Tabs.SadTab.StyleReload", event,
+                              SadTabEvent::MAX_SAD_TAB_EVENT);
+  }
+}
+
+static const int kCrashesBeforeFeedbackIsDisplayed = 1;
+static const char kCategoryTagCrash[] = "Crash";
+
+bool ShouldWantFeedback() {
+  static int total_crashes = 0;
+  return ++total_crashes > kCrashesBeforeFeedbackIsDisplayed;
+}
+
+}  // namespace
 
 namespace chrome {
 
 // static
 bool SadTab::ShouldShow(base::TerminationStatus status) {
-  return (status == base::TERMINATION_STATUS_ABNORMAL_TERMINATION ||
-          status == base::TERMINATION_STATUS_PROCESS_WAS_KILLED ||
-#if defined(OS_CHROMEOS)
-          status == base::TERMINATION_STATUS_PROCESS_WAS_KILLED_BY_OOM ||
-#endif
-          status == base::TERMINATION_STATUS_PROCESS_CRASHED ||
-          status == base::TERMINATION_STATUS_OOM);
+  switch (status) {
+    case base::TERMINATION_STATUS_ABNORMAL_TERMINATION:
+    case base::TERMINATION_STATUS_PROCESS_WAS_KILLED:
+#if defined(OS_CHROMEOS)
+    case base::TERMINATION_STATUS_PROCESS_WAS_KILLED_BY_OOM:
+#endif
+    case base::TERMINATION_STATUS_PROCESS_CRASHED:
+    case base::TERMINATION_STATUS_OOM:
+      return true;
+    case base::TERMINATION_STATUS_NORMAL_TERMINATION:
+    case base::TERMINATION_STATUS_STILL_RUNNING:
+#if defined(OS_ANDROID)
+    case base::TERMINATION_STATUS_OOM_PROTECTED:
+#endif
+    case base::TERMINATION_STATUS_LAUNCH_FAILED:
+    case base::TERMINATION_STATUS_MAX_ENUM:
+      return false;
+  }
+  CHECK(false);
+}
+
+SadTab::SadTab(content::WebContents* web_contents, SadTabKind kind)
+    : web_contents_(web_contents),
+      kind_(kind),
+      want_feedback_(ShouldWantFeedback()) {
+  switch (kind) {
+    case chrome::SAD_TAB_KIND_CRASHED:
+      UMA_SAD_TAB_COUNTER("CrashCreated");
+      break;
+    case chrome::SAD_TAB_KIND_OOM:
+      UMA_SAD_TAB_COUNTER("OomCreated");
+      break;
+#if defined(OS_CHROMEOS)
+    case chrome::SAD_TAB_KIND_KILLED_BY_OOM:
+      UMA_SAD_TAB_COUNTER("KillCreated.OOM");
+      {
+        const std::string spec = web_contents->GetURL().GetOrigin().spec();
+        memory::OomMemoryDetails::Log(
+            "Tab OOM-Killed Memory details: " + spec + ", ", base::Closure());
+      }
+// Fall through
+#endif
+    case chrome::SAD_TAB_KIND_KILLED:
+      UMA_SAD_TAB_COUNTER("KillCreated");
+      break;
+  }
+}
+
+int SadTab::GetTitle() {
+  return IDS_SAD_TAB_TITLE;
+}
+
+int SadTab::GetMessage() {
+  switch (kind_) {
+#if defined(OS_CHROMEOS)
+    case chrome::SAD_TAB_KIND_KILLED_BY_OOM:
+      return IDS_KILLED_TAB_BY_OOM_MESSAGE;
+#endif
+    case chrome::SAD_TAB_KIND_OOM:
+      return IDS_SAD_TAB_OOM_MESSAGE;
+    case chrome::SAD_TAB_KIND_CRASHED:
+    case chrome::SAD_TAB_KIND_KILLED:
+      return IDS_SAD_TAB_MESSAGE;
+  }
+  CHECK(false);

[Ilya Sherman, 2016/08/30 21:06:39]

nit: Both here and above:

  NOTREACHED();
  return 0;

[Sidney San Martín, 2016/08/30 21:18:13]

OK. I chose CHECK(false) because NOTREACHED() falls through in release builds.
Is it better to return 0 instead of crashing? I would assume (but I'm not sure)
that trying to get string ID 0 from l10n is also a crash.

+}
+
+int SadTab::GetButtonTitle() {
+  return want_feedback_ ? IDS_CRASHED_TAB_FEEDBACK_LINK
+                        : IDS_SAD_TAB_RELOAD_LABEL;
+}
+
+int SadTab::GetHelpLinkTitle() {
+  return IDS_SAD_TAB_LEARN_MORE_LINK;
+}
+
+const char* SadTab::GetHelpLinkURL() {
+  return want_feedback_ ? chrome::kCrashReasonFeedbackDisplayedURL
+                        : chrome::kCrashReasonURL;
+}
+
+void SadTab::RecordFirstPaint() {
+#if DCHECK_IS_ON()
+  DLOG_ASSERT(!recorded_paint_);
+  recorded_paint_ = true;
+#endif
+
+  switch (kind_) {
+    case chrome::SAD_TAB_KIND_CRASHED:
+      UMA_SAD_TAB_COUNTER("CrashDisplayed");
+      break;
+    case chrome::SAD_TAB_KIND_OOM:
+      UMA_SAD_TAB_COUNTER("OomDisplayed");
+      break;
+#if defined(OS_CHROMEOS)
+    case chrome::SAD_TAB_KIND_KILLED_BY_OOM:
+      UMA_SAD_TAB_COUNTER("KillDisplayed.OOM");
+// Fallthrough
+#endif
+    case chrome::SAD_TAB_KIND_KILLED:
+      UMA_SAD_TAB_COUNTER("KillDisplayed");
+      break;
+  }
+
+  RecordEvent(want_feedback_, SadTabEvent::DISPLAYED);
+}
+
+void SadTab::PerformAction(SadTab::Action action) {
+  DLOG_ASSERT(recorded_paint_);
+  switch (action) {
+    case Action::BUTTON:
+      RecordEvent(want_feedback_, SadTabEvent::BUTTON_CLICKED);
+      if (want_feedback_) {
+        chrome::ShowFeedbackPage(
+            chrome::FindBrowserWithWebContents(web_contents_),
+            l10n_util::GetStringUTF8(kind_ == chrome::SAD_TAB_KIND_CRASHED
+                                         ? IDS_CRASHED_TAB_FEEDBACK_MESSAGE
+                                         : IDS_KILLED_TAB_FEEDBACK_MESSAGE),
+            std::string(kCategoryTagCrash));
+      } else {
+        web_contents_->GetController().Reload(true);
+      }
+      break;
+    case Action::HELP_LINK:
+      RecordEvent(want_feedback_, SadTabEvent::HELP_LINK_CLICKED);
+      content::OpenURLParams params(GURL(GetHelpLinkURL()), content::Referrer(),
+                                    CURRENT_TAB, ui::PAGE_TRANSITION_LINK,
+                                    false);
+      web_contents_->OpenURL(params);
+      break;
+  }
 }
 
 }  // namespace chrome