Wrap MediaMetadata in base::Optional in content and chrome

content/browser/media/android/browser_media_session_manager_browsertest.cc

 // Copyright 2016 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/android/browser_media_session_manager.h"
 
 #include <iostream>
 #include <sstream>
 #include <utility>
 
 #include "base/command_line.h"
 #include "base/memory/ptr_util.h"
 #include "base/strings/utf_string_conversions.h"
 #include "content/browser/media/android/media_web_contents_observer_android.h"
 #include "content/public/browser/web_contents.h"
 #include "content/public/common/content_switches.h"
+#include "content/public/common/media_metadata.h"
 #include "content/public/test/browser_test_utils.h"
 #include "content/public/test/content_browser_test.h"
 #include "content/public/test/test_utils.h"
 #include "content/shell/browser/shell.h"
 #include "testing/gmock/include/gmock/gmock.h"
 
 using ::testing::_;
 using ::testing::InSequence;
 using ::testing::InvokeWithoutArgs;
 using ::testing::Ne;
 
 namespace content {
 
 namespace {
 
 // Helper function for build test javascripts.
-std::string BuildSetMetadataScript(const MediaMetadata& metadata) {
+std::string BuildSetMetadataScript(
+    const base::Optional<MediaMetadata>& metadata) {
   std::ostringstream generated_script;
 
-  generated_script << "var audio = document.createElement(\'audio\');"
-     << "audio.session = new MediaSession();"
-     << "audio.session.metadata = new MediaMetadata({"
-     << "title: \"" << metadata.title << "\", "
-     << "artist: \"" << metadata.artist << "\", "
-     << "album: \"" << metadata.album << "\", "
-     << "artwork: [";
+  generated_script
+      << "var audio = document.createElement(\'audio\');"
+      << "audio.session = new MediaSession();";
+
+  if (!metadata.has_value()) {
+    generated_script << "audio.session.metadata = null;";
+    return generated_script.str();
+  }
+
+  generated_script
+      << "audio.session.metadata = new MediaMetadata({"
+      << "title: \"" << metadata->title << "\", "
+      << "artist: \"" << metadata->artist << "\", "
+      << "album: \"" << metadata->album << "\", "
+      << "artwork: [";
 
   std::string artwork_separator = "";
-  for (const auto& artwork : metadata.artwork) {
+  for (const auto& artwork : metadata->artwork) {
     generated_script << artwork_separator << "{"
        << "src: \"" << artwork.src.spec() << "\", "
        << "type: \"" << artwork.type.string() << "\", "
        << "sizes: \"";
     for (const auto& size : artwork.sizes) {
       generated_script << size.width() << "x" << size.height() << " ";
     }
     generated_script << "\"}";
     artwork_separator = ", ";
   }
   generated_script << "]});";
 
   return generated_script.str();
 }
 
 }  // anonymous namespace
 
 // Helper function to be pretty-print error messages by GMock.
-void PrintTo(const MediaMetadata& metadata, std::ostream* os) {
-  *os << "{ title=" << metadata.title << ", ";
-  *os << "artist=" << metadata.artist << ", ";
-  *os << "album=" << metadata.album << ", ";
+void PrintTo(const base::Optional<MediaMetadata>& metadata, std::ostream* os) {
+  if (!metadata.has_value()) {
+    *os << "<null MediaMetadata>";
+    return;
+  }
+
+  *os << "{ title=" << metadata->title << ", ";
+  *os << "artist=" << metadata->artist << ", ";
+  *os << "album=" << metadata->album << ", ";
   *os << "artwork=[";
-  for (const auto& artwork : metadata.artwork) {
+  for (const auto& artwork : metadata->artwork) {
     *os << "{ src=" << artwork.src.spec() << ", ";
     *os << "type=" << artwork.type.string() << ", ";
     *os << "sizes=[";
     for (const auto& size : artwork.sizes) {
       *os <<  size.width() << "x" << size.height() << " ";
     }
     *os << "]}";
   }
   *os << "]}";
 }
 
 class MockBrowserMediaSessionManager : public BrowserMediaSessionManager {
  public:
   explicit MockBrowserMediaSessionManager(RenderFrameHost* render_frame_host)
       : BrowserMediaSessionManager(render_frame_host) {}
 
   MOCK_METHOD2(OnActiveate, void(int session_id, int request_id));
   MOCK_METHOD2(OnDeactiveate, void(int session_id, int request_id));
-  MOCK_METHOD2(OnSetMetadata, void(int session_id,
-                                   const MediaMetadata& metadata));
+  MOCK_METHOD2(OnSetMetadata, void(
+      int session_id, const base::Optional<MediaMetadata>& metadata));
 
  private:
   DISALLOW_COPY_AND_ASSIGN(MockBrowserMediaSessionManager);
 };
 
 class BrowserMediaSessionManagerBrowserTest : public ContentBrowserTest {
  public:
   BrowserMediaSessionManagerBrowserTest() = default;
   ~BrowserMediaSessionManagerBrowserTest() override = default;
 
@@ skipping 22 matching lines @@
         switches::kEnableBlinkFeatures, "MediaSession");
   }
 
   WebContents* web_contents_;
   MockBrowserMediaSessionManager* browser_media_session_manager_;
   scoped_refptr<MessageLoopRunner> message_loop_runner_;
 };
 
 IN_PROC_BROWSER_TEST_F(BrowserMediaSessionManagerBrowserTest,
                        TestMetadataPropagated) {
-  MediaMetadata expected;
-  expected.title = base::ASCIIToUTF16("title1");
-  expected.artist = base::ASCIIToUTF16("artist1");
-  expected.album = base::ASCIIToUTF16("album1");
+  base::Optional<MediaMetadata> expected = MediaMetadata();
+  expected->title = base::ASCIIToUTF16("title1");
+  expected->artist = base::ASCIIToUTF16("artist1");
+  expected->album = base::ASCIIToUTF16("album1");
   MediaMetadata::Artwork artwork;
   artwork.src = GURL("http://foo.com/bar.png");
   artwork.type = base::NullableString16(base::ASCIIToUTF16("image/png"), false);
   artwork.sizes.push_back(gfx::Size(128, 128));
-  expected.artwork.push_back(artwork);
+  expected->artwork.push_back(artwork);
 
   message_loop_runner_ = new MessageLoopRunner();
   EXPECT_CALL(*browser_media_session_manager_, OnSetMetadata(_, expected))
       .Times(1);
   ASSERT_TRUE(ExecuteScript(web_contents_->GetMainFrame(),
                             BuildSetMetadataScript(expected)));
   message_loop_runner_->Run();
 }
 
 IN_PROC_BROWSER_TEST_F(BrowserMediaSessionManagerBrowserTest,
                        TestSetMetadataTwice) {
   // Make expectations ordered.
   InSequence s;
 
-  MediaMetadata dont_care_metadata;
+  base::Optional<MediaMetadata> dont_care_metadata = MediaMetadata();
 
-  MediaMetadata expected;
-  expected.title = base::ASCIIToUTF16("title2");
-  expected.artist = base::ASCIIToUTF16("artist2");
-  expected.album = base::ASCIIToUTF16("album2");
+  base::Optional<MediaMetadata> expected = MediaMetadata();
+  expected->title = base::ASCIIToUTF16("title2");
+  expected->artist = base::ASCIIToUTF16("artist2");
+  expected->album = base::ASCIIToUTF16("album2");
   MediaMetadata::Artwork artwork;
   artwork.src = GURL("http://foo.com/bar.jpg");
   artwork.type = base::NullableString16(
       base::ASCIIToUTF16("image/jpeg"), false);
   artwork.sizes.push_back(gfx::Size(256, 256));
-  expected.artwork.push_back(artwork);
+  expected->artwork.push_back(artwork);
 
   // Set metadata for the first time.
   message_loop_runner_ = new MessageLoopRunner();
+  EXPECT_CALL(*browser_media_session_manager_,
+              OnSetMetadata(_, dont_care_metadata))
+      .Times(1);
+  ASSERT_TRUE(ExecuteScript(web_contents_->GetMainFrame(),
+                            BuildSetMetadataScript(dont_care_metadata)));
+  message_loop_runner_->Run();
+
+  // Set metadata for the second time.
+  message_loop_runner_ = new MessageLoopRunner();
+  EXPECT_CALL(*browser_media_session_manager_, OnSetMetadata(_, expected))
+      .Times(1);
+  ASSERT_TRUE(ExecuteScript(web_contents_->GetMainFrame(),
+                            BuildSetMetadataScript(expected)));
+  message_loop_runner_->Run();
+}
+
+
+IN_PROC_BROWSER_TEST_F(BrowserMediaSessionManagerBrowserTest,
+                       TestNullMetadata) {
+  // Make expectations ordered.
+  InSequence s;
+
+  base::Optional<MediaMetadata> dont_care_metadata = MediaMetadata();
+
+  base::Optional<MediaMetadata> expected;
+
+  // Set metadata for the first time.
+  message_loop_runner_ = new MessageLoopRunner();
   EXPECT_CALL(*browser_media_session_manager_,
               OnSetMetadata(_, dont_care_metadata))
       .Times(1);
   ASSERT_TRUE(ExecuteScript(web_contents_->GetMainFrame(),
                             BuildSetMetadataScript(dont_care_metadata)));
   message_loop_runner_->Run();
 
   // Set metadata for the second time.
   message_loop_runner_ = new MessageLoopRunner();
   EXPECT_CALL(*browser_media_session_manager_, OnSetMetadata(_, expected))
       .Times(1);
   ASSERT_TRUE(ExecuteScript(web_contents_->GetMainFrame(),
                             BuildSetMetadataScript(expected)));
   message_loop_runner_->Run();
 }
 
 IN_PROC_BROWSER_TEST_F(BrowserMediaSessionManagerBrowserTest,
                        TestFileArtworkRemoved) {
   // Make expectations ordered.
   InSequence s;
 
-  MediaMetadata dirty_metadata;
+  base::Optional<MediaMetadata> dirty_metadata = MediaMetadata();
   MediaMetadata::Artwork file_artwork;
   file_artwork.src = GURL("file:///foo/bar.jpg");
   file_artwork.type = base::NullableString16(
       base::ASCIIToUTF16("image/jpeg"), false);
-  dirty_metadata.artwork.push_back(file_artwork);
+  dirty_metadata->artwork.push_back(file_artwork);
 
-  MediaMetadata expected;
+  base::Optional<MediaMetadata> expected = MediaMetadata();
 
   // Set metadata for the first time.
   message_loop_runner_ = new MessageLoopRunner();
   EXPECT_CALL(*browser_media_session_manager_, OnSetMetadata(_, expected))
       .Times(1);
   ASSERT_TRUE(ExecuteScript(web_contents_->GetMainFrame(),
                             BuildSetMetadataScript(dirty_metadata)));
   message_loop_runner_->Run();
 }
 
 }  // namespace content