Record user interactions with MediaSession by action type

content/browser/media/session/media_session_impl.cc

 // Copyright 2015 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 "content/browser/media/session/media_session_impl.h"
 
 #include <algorithm>
 #include "content/browser/media/session/audio_focus_delegate.h"
 #include "content/browser/media/session/media_session_controller.h"
 #include "content/browser/media/session/media_session_player_observer.h"
 #include "content/browser/media/session/media_session_service_impl.h"
 #include "content/browser/web_contents/web_contents_impl.h"
 #include "content/public/browser/media_session.h"
 #include "content/public/browser/media_session_observer.h"
 #include "content/public/browser/navigation_handle.h"
 #include "content/public/browser/web_contents.h"
 #include "media/base/media_content_type.h"
+#include "third_party/WebKit/public/platform/modules/mediasession/media_session.mojom.h"
 
 #if defined(OS_ANDROID)
 #include "content/browser/media/session/media_session_android.h"
 #endif  // defined(OS_ANDROID)
 
 namespace content {
 
+using MediaSessionUserAction = MediaSessionUmaHelper::MediaSessionUserAction;
+
 namespace {
 
 const double kDefaultVolumeMultiplier = 1.0;
 const double kDuckingVolumeMultiplier = 0.2;
 
 using MapRenderFrameHostToDepth = std::map<RenderFrameHost*, size_t>;
 
 size_t ComputeFrameDepth(RenderFrameHost* rfh,
                          MapRenderFrameHostToDepth* map_rfh_to_depth) {
   DCHECK(rfh);
   size_t depth = 0;
   RenderFrameHost* current_frame = rfh;
   while (current_frame) {
     auto it = map_rfh_to_depth->find(current_frame);
     if (it != map_rfh_to_depth->end()) {
       depth += it->second;
       break;
     }
     ++depth;
     current_frame = current_frame->GetParent();
   }
   (*map_rfh_to_depth)[rfh] = depth;
   return depth;
 }
 
+MediaSessionUserAction MediaSessionActionToUserAction(
+    blink::mojom::MediaSessionAction action) {
+  switch (action) {
+    case blink::mojom::MediaSessionAction::PLAY:
+      return MediaSessionUserAction::Play;
+    case blink::mojom::MediaSessionAction::PAUSE:
+      return MediaSessionUserAction::Pause;
+    case blink::mojom::MediaSessionAction::PREVIOUS_TRACK:
+      return MediaSessionUserAction::PreviousTrack;
+    case blink::mojom::MediaSessionAction::NEXT_TRACK:
+      return MediaSessionUserAction::NextTrack;
+    case blink::mojom::MediaSessionAction::SEEK_BACKWARD:
+      return MediaSessionUserAction::SeekBackward;
+    case blink::mojom::MediaSessionAction::SEEK_FORWARD:
+      return MediaSessionUserAction::SeekForward;
+    default:

[mlamouri (slow - plz ping), 2017/04/07 11:15:55]

Add the case for COUNT here so all cases are taken into account and if another
is added, it will fail to compile.

[Zhiqiang Zhang (Slow), 2017/04/07 15:12:43]

Actually, the mojo enum only have LAST (= SEEK_FORWARD).
I removed default now.

+      NOTREACHED();
+  }
+  return MediaSessionUserAction::Count;
+}
+
 }  // anonymous namespace
 
 using MediaSessionSuspendedSource =
     MediaSessionUmaHelper::MediaSessionSuspendedSource;
 
 DEFINE_WEB_CONTENTS_USER_DATA_KEY(MediaSessionImpl);
 
 MediaSessionImpl::PlayerIdentifier::PlayerIdentifier(
     MediaSessionPlayerObserver* observer,
     int player_id)
@@ skipping 243 matching lines @@
   }
 
   // Otherwise, suspend the session.
   DCHECK(IsActive());
   OnSuspendInternal(SuspendType::CONTENT, State::SUSPENDED);
 }
 
 void MediaSessionImpl::Resume(SuspendType suspend_type) {
   DCHECK(IsSuspended());
 
+  if (suspend_type == SuspendType::UI) {
+    uma_helper_.RecordMediaSessionUserAction(
+        MediaSessionUmaHelper::MediaSessionUserAction::PlayDefault);
+  }
+
   // When the resume requests comes from another source than system, audio focus
   // must be requested.
   if (suspend_type != SuspendType::SYSTEM) {
     // Request audio focus again in case we lost it because another app started
     // playing while the playback was paused.
     State audio_focus_state = RequestSystemAudioFocus(audio_focus_type_)
                                   ? State::ACTIVE
                                   : State::INACTIVE;
     SetAudioFocusState(audio_focus_state);
 
     if (audio_focus_state_ != State::ACTIVE)
       return;
   }
 
   OnResumeInternal(suspend_type);
 }
 
 void MediaSessionImpl::Suspend(SuspendType suspend_type) {
   if (!IsActive())
     return;
 
+  if (suspend_type == SuspendType::UI) {
+    uma_helper_.RecordMediaSessionUserAction(
+        MediaSessionUmaHelper::MediaSessionUserAction::PlayDefault);

[mlamouri (slow - plz ping), 2017/04/07 11:15:55]

::PauseDefault?

[Zhiqiang Zhang (Slow), 2017/04/07 15:12:43]

Done.

+  }
+
   OnSuspendInternal(suspend_type, State::SUSPENDED);
 }
 
 void MediaSessionImpl::Stop(SuspendType suspend_type) {
   DCHECK(audio_focus_state_ != State::INACTIVE);
   DCHECK(suspend_type != SuspendType::CONTENT);
   DCHECK(!HasPepper());
 
+  if (suspend_type == SuspendType::UI) {
+    uma_helper_.RecordMediaSessionUserAction(
+        MediaSessionUmaHelper::MediaSessionUserAction::StopDefault);
+  }
+
   // TODO(mlamouri): merge the logic between UI and SYSTEM.
   if (suspend_type == SuspendType::SYSTEM) {
     OnSuspendInternal(suspend_type, State::INACTIVE);
     return;
   }
 
   if (audio_focus_state_ != State::SUSPENDED)
     OnSuspendInternal(suspend_type, State::SUSPENDED);
 
   DCHECK(audio_focus_state_ == State::SUSPENDED);
@@ skipping 276 matching lines @@
 void MediaSessionImpl::OnMediaSessionActionsChanged(
     MediaSessionServiceImpl* service) {
   if (service != routed_service_)
     return;
 
   NotifyMediaSessionActionsChange(routed_service_->actions());
 }
 
 void MediaSessionImpl::DidReceiveAction(
     blink::mojom::MediaSessionAction action) {
+  uma_helper_.RecordMediaSessionUserAction(
+      MediaSessionActionToUserAction(action));
+
   // Pause all players in non-routed frames if the action is PAUSE.
   //
   // This is the default PAUSE action handler per Media Session API spec. The
   // reason for pausing all players in all other sessions is to avoid the
   // players in other frames keep the session active so that the UI will always
   // show the pause button but it does not pause anything (as the routed frame
   // already pauses when responding to the PAUSE action while other frames does
   // not).
   //
   // TODO(zqzhang): Currently, this might not work well on desktop as Pepper and
@@ skipping 76 matching lines @@
     if (!IsServiceActiveForRenderFrameHost(frame))
       continue;
     best_frame = frame;
     min_depth = depth;
   }
 
   return best_frame ? services_[best_frame] : nullptr;
 }
 
 }  // namespace content