[MediaSession] Don't reset metadata and actions when the session goes uncontrollable

content/browser/media/session/media_session_impl_browsertest.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 <stddef.h>
 
 #include <list>
 #include <vector>
 
 #include "base/macros.h"
 #include "base/memory/ptr_util.h"
 #include "base/metrics/histogram_samples.h"
 #include "base/test/histogram_tester.h"
 #include "base/test/simple_test_tick_clock.h"
 #include "content/browser/media/session/audio_focus_delegate.h"
 #include "content/browser/media/session/media_session_service_impl.h"
+#include "content/browser/media/session/mock_media_session_observer.h"
 #include "content/browser/media/session/mock_media_session_player_observer.h"
 #include "content/public/browser/media_session.h"
-#include "content/public/browser/media_session_observer.h"
 #include "content/public/browser/web_contents.h"
 #include "content/public/test/content_browser_test.h"
 #include "content/shell/browser/shell.h"
 #include "media/base/media_content_type.h"
 #include "testing/gmock/include/gmock/gmock.h"
 
 using content::WebContents;
 using content::MediaSession;
 using content::MediaSessionImpl;
 using content::MediaSessionObserver;
@@ skipping 14 matching lines @@
  public:
   MockAudioFocusDelegate() {
     ON_CALL(*this, RequestAudioFocus(_)).WillByDefault(::testing::Return(true));
   }
 
   MOCK_METHOD1(RequestAudioFocus,
                bool(content::AudioFocusManager::AudioFocusType));
   MOCK_METHOD0(AbandonAudioFocus, void());
 };
 
-class MockMediaSessionObserver : public MediaSessionObserver {
- public:
-  MockMediaSessionObserver(MediaSession* media_session)
-      : MediaSessionObserver(media_session) {}
-
-  MOCK_METHOD2(MediaSessionStateChanged,
-               void(bool is_controllable, bool is_suspended));
-  MOCK_METHOD0(MediaSessionDestroyed, void());
-};
-
 class MockMediaSessionServiceImpl : public content::MediaSessionServiceImpl {
  public:
   explicit MockMediaSessionServiceImpl(content::RenderFrameHost* rfh)
       : MediaSessionServiceImpl(rfh) {}
   ~MockMediaSessionServiceImpl() override = default;
 };
 
 }  // namespace
 
 class MediaSessionImplBrowserTest : public content::ContentBrowserTest {
  protected:
   MediaSessionImplBrowserTest() = default;
 
   void SetUpOnMainThread() override {
     ContentBrowserTest::SetUpOnMainThread();
 
     media_session_ = MediaSessionImpl::Get(shell()->web_contents());
     mock_media_session_observer_.reset(
-        new MockMediaSessionObserver(media_session_));
+        new content::MockMediaSessionObserver(media_session_));
     mock_audio_focus_delegate_ = new MockAudioFocusDelegate;
     media_session_->SetDelegateForTests(
         base::WrapUnique(mock_audio_focus_delegate_));
     ASSERT_TRUE(media_session_);
   }
 
   void TearDownOnMainThread() override {
     mock_media_session_observer_.reset();
     media_session_->RemoveAllPlayersForTest();
     mock_media_session_service_.reset();
@@ skipping 61 matching lines @@
 
   void EnsureMediaSessionService() {
     mock_media_session_service_.reset(new MockMediaSessionServiceImpl(
         shell()->web_contents()->GetMainFrame()));
   }
 
   void SetPlaybackState(blink::mojom::MediaSessionPlaybackState state) {
     mock_media_session_service_->SetPlaybackState(state);
   }
 
-  MockMediaSessionObserver* mock_media_session_observer() {
+  content::MockMediaSessionObserver* mock_media_session_observer() {
     return mock_media_session_observer_.get();
   }
 
   MockAudioFocusDelegate* mock_audio_focus_delegate() {
     return mock_audio_focus_delegate_;
   }
 
   std::unique_ptr<MediaSessionImpl> CreateDummyMediaSession() {
     return base::WrapUnique<MediaSessionImpl>(new MediaSessionImpl(nullptr));
   }
 
   MediaSessionUmaHelper* GetMediaSessionUMAHelper() {
     return media_session_->uma_helper_for_test();
   }
 
  protected:
   MediaSessionImpl* media_session_;
-  std::unique_ptr<MockMediaSessionObserver> mock_media_session_observer_;
+  std::unique_ptr<content::MockMediaSessionObserver>
+      mock_media_session_observer_;
   MockAudioFocusDelegate* mock_audio_focus_delegate_;
   std::unique_ptr<MockMediaSessionServiceImpl> mock_media_session_service_;
 
   DISALLOW_COPY_AND_ASSIGN(MediaSessionImplBrowserTest);
 };
 
 IN_PROC_BROWSER_TEST_F(MediaSessionImplBrowserTest,
                        PlayersFromSameObserverDoNotStopEachOtherInSameSession) {
   auto player_observer = base::MakeUnique<MockMediaSessionPlayerObserver>();
 
@@ skipping 1220 matching lines @@
   StartNewPlayer(player_observer.get(), media::MediaContentType::Persistent);
   clock->Advance(base::TimeDelta::FromMilliseconds(1000));
   media_session_->Stop(MediaSession::SuspendType::UI);
 
   std::unique_ptr<base::HistogramSamples> samples(
       tester.GetHistogramSamplesSinceCreation("Media.Session.ActiveTime"));
   EXPECT_EQ(2, samples->TotalCount());
   EXPECT_EQ(1, samples->GetCount(1000));
   EXPECT_EQ(1, samples->GetCount(10000));
 }