Disable media key handling when locked on CrOS

Disables media key handling when locked on CrOS
because of privacy issues.

BUG=926019

Change-Id: Ib0e5fcc5f9d20b60fdc0c607d276ffddc7a846b0
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/1554795Reviewed-by: Tommy Steimel <steimel@chromium.org>
Commit-Queue: Becca Hughes <beccahughes@chromium.org>
Cr-Commit-Position: refs/heads/master@{#649163}

ash/BUILD.gn

@@ -1705,6 +1705,7 @@ test("ash_unittests") {
     "magnifier/magnifier_test_utils.h",
     "magnifier/magnifier_utils_unittest.cc",
     "magnifier/partial_magnification_controller_unittest.cc",
+    "media/media_controller_unittest.cc",
     "media/media_notification_background_unittest.cc",
     "media/media_notification_controller_unittest.cc",
     "media/media_notification_view_unittest.cc",

ash/media/media_controller.cc

@@ -4,6 +4,8 @@
 
 #include "ash/media/media_controller.h"
 
+#include "ash/session/session_controller.h"
+#include "ash/shell.h"
 #include "base/bind.h"
 #include "base/feature_list.h"
 #include "base/metrics/histogram_macros.h"
@@ -71,6 +73,9 @@ void MediaController::NotifyCaptureState(
 }
 
 void MediaController::HandleMediaPlayPause() {
+  if (Shell::Get()->session_controller()->IsScreenLocked())
+    return;
+
   // If the |client_| is force handling the keys then we should forward them.
   if (client_ && force_media_client_key_handling_) {
     ui::RecordMediaHardwareKeyAction(ui::MediaHardwareKeyAction::kPlayPause);
@@ -107,6 +112,9 @@ void MediaController::HandleMediaPlayPause() {
 }
 
 void MediaController::HandleMediaNextTrack() {
+  if (Shell::Get()->session_controller()->IsScreenLocked())
+    return;
+
   ui::RecordMediaHardwareKeyAction(
       ui::MediaHardwareKeyAction::kNextTrack);
 
@@ -128,6 +136,9 @@ void MediaController::HandleMediaNextTrack() {
 }
 
 void MediaController::HandleMediaPrevTrack() {
+  if (Shell::Get()->session_controller()->IsScreenLocked())
+    return;
+
   ui::RecordMediaHardwareKeyAction(
       ui::MediaHardwareKeyAction::kPreviousTrack);
 
@@ -182,8 +193,11 @@ void MediaController::SetMediaSessionControllerForTest(
 }
 
 void MediaController::FlushForTesting() {
-  client_.FlushForTesting();
-  media_session_controller_ptr_.FlushForTesting();
+  if (client_)
+    client_.FlushForTesting();
+
+  if (media_session_controller_ptr_)
+    media_session_controller_ptr_.FlushForTesting();
 }
 
 media_session::mojom::MediaController*

ash/media/media_controller.h

@@ -78,6 +78,7 @@ class ASH_EXPORT MediaController
       const base::Optional<base::UnguessableToken>& request_id) override {}
 
  private:
+  friend class MediaControllerTest;
   friend class MediaSessionAcceleratorTest;
   friend class MultiProfileMediaTrayItemTest;
   FRIEND_TEST_ALL_PREFIXES(MediaSessionAcceleratorTest,

ash/media/media_controller_unittest.cc

+// Copyright 2018 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 "ash/media/media_controller.h"
+
+#include <memory>
+
+#include "ash/session/session_controller.h"
+#include "ash/shell.h"
+#include "ash/test/ash_test_base.h"
+#include "base/macros.h"
+#include "services/media_session/public/cpp/test/test_media_controller.h"
+
+namespace ash {
+
+class MediaControllerTest : public AshTestBase {
+ public:
+  MediaControllerTest() = default;
+  ~MediaControllerTest() override = default;
+
+  // AshTestBase
+  void SetUp() override {
+    AshTestBase::SetUp();
+
+    controller_ = std::make_unique<media_session::test::TestMediaController>();
+
+    MediaController* media_controller = Shell::Get()->media_controller();
+    media_controller->SetMediaSessionControllerForTest(
+        controller_->CreateMediaControllerPtr());
+    media_controller->FlushForTesting();
+
+    {
+      std::vector<media_session::mojom::MediaSessionAction> actions;
+      actions.push_back(media_session::mojom::MediaSessionAction::kPlay);
+      controller_->SimulateMediaSessionActionsChanged(actions);
+    }
+
+    {
+      media_session::mojom::MediaSessionInfoPtr session_info(
+        media_session::mojom::MediaSessionInfo::New());
+
+      session_info->state =
+          media_session::mojom::MediaSessionInfo::SessionState::kActive;
+      session_info->playback_state =
+          media_session::mojom::MediaPlaybackState::kPlaying;
+      controller_->SimulateMediaSessionInfoChanged(std::move(session_info));
+    }
+
+    Flush();
+  }
+
+  media_session::test::TestMediaController* controller() const {
+    return controller_.get();
+  }
+
+  void SimulateSessionLock() {
+    mojom::SessionInfoPtr info_ptr = mojom::SessionInfo::New();
+    info_ptr->state = session_manager::SessionState::LOCKED;
+    Shell::Get()->session_controller()->SetSessionInfo(std::move(info_ptr));
+  }
+
+  void Flush() {
+    controller_->Flush();
+    Shell::Get()->media_controller()->FlushForTesting();
+  }
+
+ private:
+  std::unique_ptr<media_session::test::TestMediaController> controller_;
+
+  DISALLOW_COPY_AND_ASSIGN(MediaControllerTest);
+};
+
+TEST_F(MediaControllerTest, DisablePlayPauseWhenLocked) {
+  EXPECT_EQ(0, controller()->suspend_count());
+
+  Shell::Get()->media_controller()->HandleMediaPlayPause();
+  Flush();
+
+  EXPECT_EQ(1, controller()->suspend_count());
+
+  SimulateSessionLock();
+
+  Shell::Get()->media_controller()->HandleMediaPlayPause();
+  Flush();
+
+  EXPECT_EQ(1, controller()->suspend_count());
+}
+
+TEST_F(MediaControllerTest, DisablePreviousTrackWhenLocked) {
+  EXPECT_EQ(0, controller()->previous_track_count());
+
+  Shell::Get()->media_controller()->HandleMediaPrevTrack();
+  Flush();
+
+  EXPECT_EQ(1, controller()->previous_track_count());
+
+  SimulateSessionLock();
+
+  Shell::Get()->media_controller()->HandleMediaPrevTrack();
+  Flush();
+
+  EXPECT_EQ(1, controller()->previous_track_count());
+}
+
+TEST_F(MediaControllerTest, DisableNextTrackWhenLocked) {
+  EXPECT_EQ(0, controller()->next_track_count());
+
+  Shell::Get()->media_controller()->HandleMediaNextTrack();
+  Flush();
+
+  EXPECT_EQ(1, controller()->next_track_count());
+
+  SimulateSessionLock();
+
+  Shell::Get()->media_controller()->HandleMediaNextTrack();
+  Flush();
+
+  EXPECT_EQ(1, controller()->next_track_count());
+}
+
+}  // namespace ash