[Cocoa] Tab audio mute control, behind a switch (off by default).

chrome/browser/ui/cocoa/tabs/tab_controller_unittest.mm

 // Copyright (c) 2011 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.
 
 #import <Cocoa/Cocoa.h>
 
 #import "base/mac/scoped_nsobject.h"
 #include "base/strings/utf_string_conversions.h"
 #include "chrome/browser/ui/cocoa/cocoa_test_helper.h"
-#import "chrome/browser/ui/cocoa/tabs/media_indicator_view.h"
+#import "chrome/browser/ui/cocoa/tabs/media_indicator_button.h"
 #import "chrome/browser/ui/cocoa/tabs/tab_controller.h"
 #import "chrome/browser/ui/cocoa/tabs/tab_controller_target.h"
 #import "chrome/browser/ui/cocoa/tabs/tab_strip_drag_controller.h"
 #import "chrome/browser/ui/cocoa/tabs/tab_view.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #import "testing/gtest_mac.h"
 #include "testing/platform_test.h"
 #include "ui/base/resource/resource_bundle.h"
 #include "ui/resources/grit/ui_resources.h"
 
@@ skipping 78 matching lines @@
 // inherit from CocoaTest to have one created for us.
 class TabControllerTest : public CocoaTest {
  public:
   TabControllerTest() { }
 
   static void CheckForExpectedLayoutAndVisibilityOfSubviews(
       const TabController* controller) {
     // Check whether subviews should be visible when they are supposed to be,
     // given Tab size and TabRendererData state.
     const TabMediaState indicatorState =
-        [[controller mediaIndicatorView] mediaState];
+        [[controller mediaIndicatorButton] showingMediaState];
     if ([controller mini]) {
       EXPECT_EQ(1, [controller iconCapacity]);
       if (indicatorState != TAB_MEDIA_STATE_NONE) {
         EXPECT_FALSE([controller shouldShowIcon]);
         EXPECT_TRUE([controller shouldShowMediaIndicator]);
       } else {
         EXPECT_TRUE([controller shouldShowIcon]);
         EXPECT_FALSE([controller shouldShowMediaIndicator]);
       }
       EXPECT_FALSE([controller shouldShowCloseButton]);
@@ skipping 49 matching lines @@
             EXPECT_FALSE([controller shouldShowMediaIndicator]);
           break;
       }
     }
 
     // Make sure the NSView's "isHidden" state jives with the "shouldShowXXX."
     EXPECT_TRUE([controller shouldShowIcon] ==
                 (!![controller iconView] && ![[controller iconView] isHidden]));
     EXPECT_TRUE([controller mini] == [[controller tabView] titleHidden]);
     EXPECT_TRUE([controller shouldShowMediaIndicator] ==
-                    ![[controller mediaIndicatorView] isHidden]);
+                    ![[controller mediaIndicatorButton] isHidden]);
     EXPECT_TRUE([controller shouldShowCloseButton] !=
                     [[controller closeButton] isHidden]);
 
     // Check positioning of elements with respect to each other, and that they
     // are fully within the tab frame.
     const NSRect tabFrame = [[controller view] frame];
     const NSRect titleFrame = [[controller tabView] titleFrame];
     if ([controller shouldShowIcon]) {
       const NSRect iconFrame = [[controller iconView] frame];
       EXPECT_LE(NSMinX(tabFrame), NSMinX(iconFrame));
       if (NSWidth(titleFrame) > 0)
         EXPECT_LE(NSMaxX(iconFrame), NSMinX(titleFrame));
       EXPECT_LE(NSMinY(tabFrame), NSMinY(iconFrame));
       EXPECT_LE(NSMaxY(iconFrame), NSMaxY(tabFrame));
     }
     if ([controller shouldShowIcon] && [controller shouldShowMediaIndicator]) {
       EXPECT_LE(NSMaxX([[controller iconView] frame]),
-                NSMinX([[controller mediaIndicatorView] frame]));
+                NSMinX([[controller mediaIndicatorButton] frame]));
     }
     if ([controller shouldShowMediaIndicator]) {
       const NSRect mediaIndicatorFrame =
-          [[controller mediaIndicatorView] frame];
+          [[controller mediaIndicatorButton] frame];
       if (NSWidth(titleFrame) > 0)
         EXPECT_LE(NSMaxX(titleFrame), NSMinX(mediaIndicatorFrame));
       EXPECT_LE(NSMaxX(mediaIndicatorFrame), NSMaxX(tabFrame));
       EXPECT_LE(NSMinY(tabFrame), NSMinY(mediaIndicatorFrame));
       EXPECT_LE(NSMaxY(mediaIndicatorFrame), NSMaxY(tabFrame));
     }
     if ([controller shouldShowMediaIndicator] &&
         [controller shouldShowCloseButton]) {
-      EXPECT_LE(NSMaxX([[controller mediaIndicatorView] frame]),
+      EXPECT_LE(NSMaxX([[controller mediaIndicatorButton] frame]),
                 NSMinX([[controller closeButton] frame]));
     }
     if ([controller shouldShowCloseButton]) {
       const NSRect closeButtonFrame = [[controller closeButton] frame];
       if (NSWidth(titleFrame) > 0)
         EXPECT_LE(NSMaxX(titleFrame), NSMinX(closeButtonFrame));
       EXPECT_LE(NSMaxX(closeButtonFrame), NSMaxX(tabFrame));
       EXPECT_LE(NSMinY(tabFrame), NSMinY(closeButtonFrame));
       EXPECT_LE(NSMaxY(closeButtonFrame), NSMaxY(tabFrame));
     }
@@ skipping 240 matching lines @@
             NSWidth([[controller tabView] titleFrame]));
   EXPECT_EQ(LeftMargin(originalTabFrame, originalTitleFrame),
             LeftMargin([[controller view] frame],
                        [[controller tabView] titleFrame]));
   EXPECT_EQ(RightMargin(originalTabFrame, originalTitleFrame),
             RightMargin([[controller view] frame],
                         [[controller tabView] titleFrame]));
 }
 
 // A comprehensive test of the layout and visibility of all elements (favicon,
-// throbber indicators, titile text, audio indicator, and close button) over all
-// relevant combinations of tab state.  This test overlaps with parts of the
-// other tests above.
+// throbber indicators, titile text, media indicator button, and close button)
+// over all relevant combinations of tab state.  This test overlaps with parts
+// of the other tests above.
 // Flaky: https://code.google.com/p/chromium/issues/detail?id=311668
 TEST_F(TabControllerTest, DISABLED_LayoutAndVisibilityOfSubviews) {
   static const TabMediaState kMediaStatesToTest[] = {
     TAB_MEDIA_STATE_NONE, TAB_MEDIA_STATE_CAPTURING,
-    TAB_MEDIA_STATE_AUDIO_PLAYING
+    TAB_MEDIA_STATE_AUDIO_PLAYING, TAB_MEDIA_STATE_AUDIO_MUTING
   };
 
   NSWindow* const window = test_window();
 
   // Create TabController instance and place its view into the test window.
   base::scoped_nsobject<TabController> controller([[TabController alloc] init]);
   [[window contentView] addSubview:[controller view]];
 
-  // Create favicon and media indicator views.  Disable animation in the media
-  // indicator view so that TabController's "what should be shown" logic can be
-  // tested effectively.  If animations were left enabled, the
-  // shouldShowMediaIndicator method would return true during fade-out
-  // transitions.
+  // Create favicon.
   ui::ResourceBundle& rb = ui::ResourceBundle::GetSharedInstance();
   base::scoped_nsobject<NSImage> favicon(
       rb.GetNativeImageNamed(IDR_DEFAULT_FAVICON).CopyNSImage());
-  base::scoped_nsobject<MediaIndicatorView> mediaIndicatorView(
-      [[MediaIndicatorView alloc] init]);
-  [mediaIndicatorView disableAnimations];
-  [controller setMediaIndicatorView:mediaIndicatorView];
+
+  // Trigger TabController to auto-create the MediaIndicatorButton.
+  [controller setMediaState:TAB_MEDIA_STATE_AUDIO_PLAYING];
+  [controller setMediaState:TAB_MEDIA_STATE_NONE];
+  base::scoped_nsobject<MediaIndicatorButton> mediaIndicatorButton(
+      [[controller mediaIndicatorButton] retain]);
+  ASSERT_TRUE(mediaIndicatorButton.get());
 
   // Perform layout over all possible combinations, checking for correct
   // results.
   for (int isMiniTab = 0; isMiniTab < 2; ++isMiniTab) {
     for (int isActiveTab = 0; isActiveTab < 2; ++isActiveTab) {
       for (size_t mediaStateIndex = 0;
            mediaStateIndex < arraysize(kMediaStatesToTest);
            ++mediaStateIndex) {
         const TabMediaState mediaState = kMediaStatesToTest[mediaStateIndex];
         SCOPED_TRACE(::testing::Message()
                      << (isActiveTab ? "Active" : "Inactive") << ' '
                      << (isMiniTab ? "Mini " : "")
                      << "Tab with media indicator state " << mediaState);
 
         // Simulate what tab_strip_controller would do to set up the
         // TabController state.
         [controller setMini:(isMiniTab ? YES : NO)];
         [controller setActive:(isActiveTab ? YES : NO)];
-        [[controller mediaIndicatorView] updateIndicator:mediaState];
         [controller setIconImage:favicon];
+        [controller setMediaState:mediaState];
+        [controller updateVisibility];
 
         // Test layout for every width from maximum to minimum.
         NSRect tabFrame = [[controller view] frame];
         int minWidth;
         if (isMiniTab) {
           tabFrame.size.width = minWidth = [TabController miniTabWidth];
         } else {
           tabFrame.size.width = [TabController maxTabWidth];
           minWidth = isActiveTab ? [TabController minActiveTabWidth] :
               [TabController minTabWidth];
         }
         while (NSWidth(tabFrame) >= minWidth) {
           SCOPED_TRACE(::testing::Message() << "width=" << tabFrame.size.width);
           [[controller view] setFrame:tabFrame];
           CheckForExpectedLayoutAndVisibilityOfSubviews(controller);
           --tabFrame.size.width;
         }
       }
     }
   }
 }
 
 }  // namespace