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;
+  }
+  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) {
+    MediaSessionUmaHelper::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) {
+    MediaSessionUmaHelper::RecordMediaSessionUserAction(
+        MediaSessionUserAction::PauseDefault);
+  }
+
   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) {
+    MediaSessionUmaHelper::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) {
+  MediaSessionUmaHelper::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
   // OneShot players are not really suspended, so that the session is still
   // active after this. See https://crbug.com/619084 and
   // https://crbug.com/596516.
   if (blink::mojom::MediaSessionAction::PAUSE == action) {
     RenderFrameHost* rfh_of_routed_service =
         routed_service_ ? routed_service_->GetRenderFrameHost() : nullptr;
     for (const auto& player : normal_players_) {
-      if (player.observer->GetRenderFrameHost() != rfh_of_routed_service)
+      if (player.observer->render_frame_host() != rfh_of_routed_service)
         player.observer->OnSuspend(player.player_id);
     }
     for (const auto& player : pepper_players_) {
-      if (player.observer->GetRenderFrameHost() != rfh_of_routed_service) {
+      if (player.observer->render_frame_host() != rfh_of_routed_service) {
         player.observer->OnSetVolumeMultiplier(player.player_id,
                                                kDuckingVolumeMultiplier);
       }
     }
     for (const auto& player : one_shot_players_) {
-      if (player.observer->GetRenderFrameHost() != rfh_of_routed_service)
+      if (player.observer->render_frame_host() != rfh_of_routed_service)
         player.observer->OnSuspend(player.player_id);
     }
   }
 
   if (!routed_service_)
     return;
 
   routed_service_->GetClient()->DidReceiveAction(action);
 }
 
@@ skipping 13 matching lines @@
   }
 }
 
 MediaSessionServiceImpl* MediaSessionImpl::ComputeServiceForRouting() {
   // The service selection strategy is: select a frame that has a playing/paused
   // player and has a corresponding MediaSessionService and return the
   // corresponding MediaSessionService. If multiple frames satisfy the criteria,
   // prefer the top-most frame.
   std::set<RenderFrameHost*> frames;
   for (const auto& player : normal_players_) {
-    RenderFrameHost* frame = player.observer->GetRenderFrameHost();
+    RenderFrameHost* frame = player.observer->render_frame_host();
     if (frame)
       frames.insert(frame);
   }
 
   for (const auto& player : one_shot_players_) {
-    RenderFrameHost* frame = player.observer->GetRenderFrameHost();
+    RenderFrameHost* frame = player.observer->render_frame_host();
     if (frame)
       frames.insert(frame);
   }
 
   for (const auto& player : pepper_players_) {
-    RenderFrameHost* frame = player.observer->GetRenderFrameHost();
+    RenderFrameHost* frame = player.observer->render_frame_host();
     if (frame)
       frames.insert(frame);
   }
 
   RenderFrameHost* best_frame = nullptr;
   size_t min_depth = std::numeric_limits<size_t>::max();
   std::map<RenderFrameHost*, size_t> map_rfh_to_depth;
 
   for (RenderFrameHost* frame : frames) {
     size_t depth = ComputeFrameDepth(frame, &map_rfh_to_depth);
     if (depth >= min_depth)
       continue;
     if (!IsServiceActiveForRenderFrameHost(frame))
       continue;
     best_frame = frame;
     min_depth = depth;
   }
 
   return best_frame ? services_[best_frame] : nullptr;
 }
 
 }  // namespace content