mac: Add metrics for fullscreen entry.

chrome/browser/ui/cocoa/browser_window_controller_private.mm

 // 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.
 
 #import "chrome/browser/ui/cocoa/browser_window_controller_private.h"
 
 #include <cmath>
 
 #include "base/command_line.h"
 #include "base/mac/mac_util.h"
 #import "base/mac/scoped_nsobject.h"
 #import "base/mac/sdk_forward_declarations.h"
+#include "base/metrics/histogram.h"
 #include "base/prefs/pref_service.h"
 #include "base/prefs/scoped_user_pref_update.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/fullscreen.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/profiles/profile_avatar_icon_util.h"
 #include "chrome/browser/ui/bookmarks/bookmark_tab_helper.h"
 #include "chrome/browser/ui/browser.h"
 #include "chrome/browser/ui/browser_window_state.h"
 #import "chrome/browser/ui/cocoa/browser_window_layout.h"
@@ skipping 25 matching lines @@
 #include "ui/base/ui_base_types.h"
 
 using content::RenderWidgetHostView;
 using content::WebContents;
 
 namespace {
 
 // Space between the incognito badge and the right edge of the window.
 const CGFloat kAvatarRightOffset = 4;
 
+// Each time the user enters fullscreen, a single histogram enumeration is
+// recorded. There are several relevant parameters, whose values are mapped
+// directly into individual bits of the enumeration.
+//
+// + Fullscreen Mechanism: The mechanism by which the window's size is changed

[Robert Sesek, 2014/10/01 15:41:51]

Is this really an interesting metric? This will just test user vs. web initiated
fullscreen. Don't we really want to differentiate between entering "Presentation
Mode" and entering "Fullscreen"? (Or maybe we want both of these metricS).

[erikchen, 2014/10/01 16:47:44]

I intend to create a separate metric for presentation mode vs canonical
fullscreen.

We want both of the metrics. In a world where our analytics supported events
with properties, both of the metrics would be properties for this event. As it
stands, there's a tradeoff between adding more "properties" to this enumeration,
and readability of the results. Given the mirrored mechanisms of entry into
presentation mode and canonical fullscreen, I judged that the results from that
measurement would likely be independent from the properties measured in this
event, and thus could be measured separately.

+// to encompass the entire screen. Bit 0.
+//   - AppKit (value of bit: 1)
+//   - Immersive (value of bit: 0)
+//
+// + Primary Screen: Whether the window is located on the screen at index 0.
+// Depending on OSX version, this has different implications for menu bar
+// visibility. Bit 1.
+//   - Primary (value of bit: 1)
+//   - Secondary (value of bit: 0)
+//
+// + Displays have separate spaces: An option available in Mission Control in
+// OSX 10.9+. Bit 2.
+//   - On (value of bit: 1)
+//   - Off (value of bit: 0)
+//
+// + Multiple screens: Whether the user has multiple screens. If the window is

[Robert Sesek, 2014/10/01 15:41:51]

I thought this was going to be tracked once per startup? Also, I think doing a
histogram counts would be better than just a boolean, so that we can know if
users have 1, 2, 3, or 42 monitors.

[erikchen, 2014/10/01 16:47:44]

I intend on creating a separate metric, which is why this CL is not tied to that
bug.

+// located on a secondary screen, then there must be multiple screens. Bit 3.
+//   - Yes (value of bit: 1)
+//   - No (value of bit: 0)
+
+enum FullscreenMechanism {
+  IMMERSIVE_FULLSCREEN_MECHANISM,
+  APPKIT_FULLSCREEN_MECHANISM,
+};
+
+enum {
+  FULLSCREEN_MECHANISM_BIT = 0,
+  PRIMARY_SCREEN_BIT = 1,
+  DISPLAYS_SEPARATE_SPACES_BIT = 2,
+  MULTIPLE_SCREENS_BIT = 3,
+  BIT_COUNT
+};
+
+// Emits a histogram entry indicating that |window| is being made fullscreen.
+void RecordFullscreenHistogram(FullscreenMechanism mechanism,
+                               NSWindow* window) {
+  NSArray* screens = [NSScreen screens];
+  bool primary_screen = ([window screen] == [screens objectAtIndex:0]);
+  bool displays_have_separate_spaces = [NSScreen screensHaveSeparateSpaces];

[Robert Sesek, 2014/10/08 19:28:48]

This will crash anything < 10.9.

[erikchen, 2014/10/08 23:50:45]

Right you are. Thanks!

+  bool multiple_screens = [screens count] > 1;
+
+  int output = 0;
+  if (mechanism == APPKIT_FULLSCREEN_MECHANISM)
+    output += 1 << FULLSCREEN_MECHANISM_BIT;
+
+  if (primary_screen)
+    output += 1 << PRIMARY_SCREEN_BIT;
+
+  if (displays_have_separate_spaces)
+    output += 1 << DISPLAYS_SEPARATE_SPACES_BIT;
+
+  if (multiple_screens)
+    output += 1 << MULTIPLE_SCREENS_BIT;
+
+  int max_output = 1 << BIT_COUNT;
+  UMA_HISTOGRAM_ENUMERATION("OSX.Fullscreen.Enter", output, max_output);

[Robert Sesek, 2014/10/01 15:41:51]

I think this histogram is going to be harder to understand than just tracking
each one of these items uniquely.

[erikchen, 2014/10/01 16:47:44]

I agree, but tracking the items separately loses information, which we may
actually care about. For example, let's say that 10% of people use fullscreen on
a second monitor, and 30% of people use AppKit Fullscreen. We might naively
think that 3% of people use AppKit Fullscreen on a second monitior, but it's
possible that these properties are not independent, and that all 10% of people
who use a second monitor also use AppKit Fullscreen.

+}
+
 }  // namespace
 
 @implementation BrowserWindowController(Private)
 
 // Create the tab strip controller.
 - (void)createTabStripController {
   DCHECK([overlayableContentsController_ activeContainer]);
   DCHECK([[overlayableContentsController_ activeContainer] window]);
   tabStripController_.reset([[TabStripController alloc]
       initWithView:[self tabStripView]
@@ skipping 441 matching lines @@
   [self layoutSubviews];
 }
 
 - (PresentationModeController*)newPresentationModeControllerWithStyle:
     (fullscreen_mac::SlidingStyle)style {
   return [[PresentationModeController alloc] initWithBrowserController:self
                                                                  style:style];
 }
 
 - (void)enterImmersiveFullscreen {
+  RecordFullscreenHistogram(IMMERSIVE_FULLSCREEN_MECHANISM, [self window]);
+
   // Set to NO by |-windowDidEnterFullScreen:|.
   enteringImmersiveFullscreen_ = YES;
 
   // Fade to black.
   const CGDisplayReservationInterval kFadeDurationSeconds = 0.6;
   Boolean didFadeOut = NO;
   CGDisplayFadeReservationToken token;
   if (CGAcquireDisplayFadeReservation(kFadeDurationSeconds, &token)
       == kCGErrorSuccess) {
     didFadeOut = YES;
@@ skipping 132 matching lines @@
 }
 
 - (NSApplicationPresentationOptions)window:(NSWindow*)window
     willUseFullScreenPresentationOptions:(NSApplicationPresentationOptions)opt {
   return (opt |
           NSApplicationPresentationAutoHideDock |
           NSApplicationPresentationAutoHideMenuBar);
 }
 
 - (void)windowWillEnterFullScreen:(NSNotification*)notification {
+  RecordFullscreenHistogram(APPKIT_FULLSCREEN_MECHANISM, [self window]);
+
   if (notification)  // For System Fullscreen when non-nil.
     [self registerForContentViewResizeNotifications];
 
   NSWindow* window = [self window];
   savedRegularWindowFrame_ = [window frame];
   BOOL mode = enteringPresentationMode_ ||
        browser_->fullscreen_controller()->IsWindowFullscreenForTabOrPending();
   enteringAppKitFullscreen_ = YES;
 
   fullscreen_mac::SlidingStyle style =
@@ skipping 351 matching lines @@
 
       [CATransaction commit];
       hasAdjustedTabStripWhileEnteringAppKitFullscreen_ = YES;
     }
   } else {
     hasAdjustedTabStripWhileEnteringAppKitFullscreen_ = NO;
   }
 }
 
 @end  // @implementation BrowserWindowController(Private)