Removed emojis from generated_resources.grd and update the code.

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

 // Copyright (c) 2012 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>
 
 #include "base/bind_helpers.h"
 #include "base/mac/scoped_nsautorelease_pool.h"
 #include "chrome/browser/media/media_capture_devices_dispatcher.h"
 #include "chrome/browser/media/media_stream_capture_indicator.h"
 #include "chrome/browser/ui/browser_window.h"
+#import "chrome/browser/ui/cocoa/browser_window_controller.h"
 #include "chrome/browser/ui/cocoa/cocoa_profile_test.h"
 #import "chrome/browser/ui/cocoa/new_tab_button.h"
 #import "chrome/browser/ui/cocoa/tabs/tab_controller.h"
 #import "chrome/browser/ui/cocoa/tabs/tab_strip_controller.h"
 #import "chrome/browser/ui/cocoa/tabs/tab_strip_view.h"
 #import "chrome/browser/ui/cocoa/tabs/tab_view.h"
 #include "chrome/browser/ui/tabs/tab_utils.h"
 #include "chrome/browser/ui/tabs/test_tab_strip_model_delegate.h"
 #include "chrome/test/base/testing_profile.h"
 #include "content/public/browser/site_instance.h"
 #include "content/public/browser/web_contents.h"
 #include "content/public/common/media_stream_request.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #import "testing/gtest_mac.h"
 #include "testing/platform_test.h"
 #include "ui/events/test/cocoa_test_event_utils.h"
 
 using content::SiteInstance;
 using content::WebContents;
 
+@interface TabStripControllerForMediaTesting : TabStripController {
+  // Keeps media state of tabs in browser for testing purpose.
+  std::map<content::WebContents*, TabMediaState> contentsMediaStateMaps_;
+}
+@end
+
+@implementation TabStripControllerForMediaTesting
+// Returns the media state of each tab from the map we are keeping.
+- (TabMediaState)mediaStateForContents:(content::WebContents*)contents {
+  return contentsMediaStateMaps_[contents];
+}
+
+- (void)setMediaStateForContents:(content::WebContents*)contents
+                  withMediaState:(TabMediaState)media_state {
+  contentsMediaStateMaps_[contents] = media_state;
+}
+
+@end
+
 @interface TestTabStripControllerDelegate
     : NSObject<TabStripControllerDelegate> {
 }
 @end
 
 @implementation TestTabStripControllerDelegate
 - (void)onActivateTabWithContents:(WebContents*)contents {
 }
 - (void)onTabChanged:(TabStripModelObserver::TabChangeType)change
         withContents:(WebContents*)contents {
@@ skipping 53 matching lines @@
 
     NSWindow* window = browser()->window()->GetNativeWindow();
     NSView* parent = [window contentView];
     NSRect content_frame = [parent frame];
 
     // Create the "switch view" (view that gets changed out when a tab
     // switches).
     NSRect switch_frame = NSMakeRect(0, 0, content_frame.size.width, 500);
     base::scoped_nsobject<NSView> switch_view(
         [[NSView alloc] initWithFrame:switch_frame]);
-    [parent addSubview:switch_view.get()];
+    switch_view_ = switch_view;
+    [parent addSubview:switch_view_.get()];
 
     // Create the tab strip view. It's expected to have a child button in it
     // already as the "new tab" button so create that too.
     NSRect strip_frame = NSMakeRect(0, NSMaxY(switch_frame),
                                     content_frame.size.width, 30);
     tab_strip_.reset(
         [[TabStripView alloc] initWithFrame:strip_frame]);
     [parent addSubview:tab_strip_.get()];
     NSRect button_frame = NSMakeRect(0, 0, 15, 15);
     base::scoped_nsobject<NewTabButton> new_tab_button(
@@ skipping 12 matching lines @@
   }
 
   void TearDown() override {
     // The call to CocoaTest::TearDown() deletes the Browser and TabStripModel
     // objects, so we first have to delete the controller, which refers to them.
     controller_.reset();
     model_ = NULL;
     CocoaProfileTest::TearDown();
   }
 
+  // Return a derived TabStripController.
+  TabStripControllerForMediaTesting* InitTabStripControllerForMediaTesting() {
+    TabStripControllerForMediaTesting* c =
+        [[TabStripControllerForMediaTesting alloc]
+            initWithView:static_cast<TabStripView*>(tab_strip_.get())
+              switchView:switch_view_.get()
+                 browser:browser()
+                delegate:controller_delegate_.get()];
+    return c;
+  }
+
   TabView* CreateTab() {
     SiteInstance* instance = SiteInstance::Create(profile());
     WebContents* web_contents = WebContents::Create(
         content::WebContents::CreateParams(profile(), instance));
     model_->AppendWebContents(web_contents, true);
     const NSUInteger tab_count = [controller_.get() viewsCount];
     return static_cast<TabView*>([controller_.get() viewAtIndex:tab_count - 1]);
   }
 
   // Closes all tabs and unrefs the tabstrip and then posts a NSLeftMouseUp
   // event which should end the nested drag event loop.
   void CloseTabsAndEndDrag() {
     // Simulate a close of the browser window.
     model_->CloseAllTabs();
     controller_.reset();
     tab_strip_.reset();
     // Schedule a NSLeftMouseUp to end the nested drag event loop.
     NSEvent* event =
         cocoa_test_event_utils::MouseEventWithType(NSLeftMouseUp, 0);
     [NSApp postEvent:event atStart:NO];
   }
 
   scoped_ptr<TestTabStripModelDelegate> delegate_;
   TabStripModel* model_;
   base::scoped_nsobject<TestTabStripControllerDelegate> controller_delegate_;
   base::scoped_nsobject<TabStripController> controller_;
   base::scoped_nsobject<TabStripView> tab_strip_;
+  base::scoped_nsobject<NSView> switch_view_;
 };
 
 // Test adding and removing tabs and making sure that views get added to
 // the tab strip.
 TEST_F(TabStripControllerTest, AddRemoveTabs) {
   EXPECT_TRUE(model_->empty());
   CreateTab();
   EXPECT_EQ(model_->count(), 1);
 }
 
@@ skipping 167 matching lines @@
   EXPECT_EQ(tab2, value);
 
   model_->ActivateTabAt(0, false);
   EXPECT_TRUE([tab1 controller].selected);
   EXPECT_FALSE([tab2 controller].selected);
   value =
       [tab_strip_ accessibilityAttributeValue:NSAccessibilityValueAttribute];
   EXPECT_EQ(tab1, value);
 }
 
+TEST_F(TabStripControllerTest, CorrectWindowFromUpdateWindowMediaState) {
+  controller_.reset(InitTabStripControllerForMediaTesting());
+  NSWindow* window = [tab_strip_ window];
+  BrowserWindowController* window_controller =
+      [BrowserWindowController browserWindowControllerForWindow:window];
+  TabStripControllerForMediaTesting* tabStripControllerForTesting =
+      static_cast<TabStripControllerForMediaTesting*>(controller_);
+
+  TabView* const tab1 = CreateTab();
+  TabView* const tab2 = CreateTab();
+
+  // tab2 should be the selected one.
+  EXPECT_FALSE([tab1 controller].selected);
+  EXPECT_TRUE([tab2 controller].selected);
+  WebContents* const contents_at_tab1 = model_->GetActiveWebContents();
+
+  [tabStripControllerForTesting
+      setMediaStateForContents:contents_at_tab1
+                withMediaState:TAB_MEDIA_STATE_AUDIO_PLAYING];
+  // Make sure the overriden from base controller correctly handles media
+  // status of tabs.
+  EXPECT_EQ(TAB_MEDIA_STATE_AUDIO_PLAYING,
+            [controller_ mediaStateForContents:contents_at_tab1]);
+  [controller_ updateWindowMediaState:TAB_MEDIA_STATE_AUDIO_PLAYING
+                       forWebContents:contents_at_tab1];
+  // Because we have one tab playing, and the other one's media state is none,
+  // window media state should be AUDIO_PLAYING.
+  EXPECT_EQ(TAB_MEDIA_STATE_AUDIO_PLAYING, [window_controller mediaState]);
+
+  model_->ActivateTabAt(0, false);
+  // tab1 should be the selected one now.
+  EXPECT_TRUE([tab1 controller].selected);
+  EXPECT_FALSE([tab2 controller].selected);
+  WebContents* const contents_at_tab0 = model_->GetActiveWebContents();
+
+  [tabStripControllerForTesting
+      setMediaStateForContents:contents_at_tab0
+                withMediaState:TAB_MEDIA_STATE_AUDIO_MUTING];
+  [controller_ updateWindowMediaState:TAB_MEDIA_STATE_AUDIO_MUTING
+                       forWebContents:contents_at_tab0];
+  // We have two tabs. One is playing and the other one is muting. The window
+  // media state should be still AUDIO_PLAYING.
+  EXPECT_EQ(TAB_MEDIA_STATE_AUDIO_PLAYING, [window_controller mediaState]);
+
+  [tabStripControllerForTesting
+      setMediaStateForContents:contents_at_tab1
+                withMediaState:TAB_MEDIA_STATE_AUDIO_MUTING];
+  [controller_ updateWindowMediaState:TAB_MEDIA_STATE_AUDIO_MUTING
+                       forWebContents:contents_at_tab1];
+  // Now both tabs are muting, the window media state should be AUDIO_MUTING.
+  EXPECT_EQ(TAB_MEDIA_STATE_AUDIO_MUTING, [window_controller mediaState]);
+
+  [tabStripControllerForTesting
+      setMediaStateForContents:contents_at_tab0
+                withMediaState:TAB_MEDIA_STATE_AUDIO_PLAYING];
+  [controller_ updateWindowMediaState:TAB_MEDIA_STATE_AUDIO_PLAYING
+                       forWebContents:contents_at_tab0];
+  // Among those tabs which were muting, one is started playing, the window
+  // media state should be playing.
+  EXPECT_EQ(TAB_MEDIA_STATE_AUDIO_PLAYING, [window_controller mediaState]);
+
+  // Mute it again for further testing.
+  [tabStripControllerForTesting
+      setMediaStateForContents:contents_at_tab0
+                withMediaState:TAB_MEDIA_STATE_AUDIO_MUTING];
+  [controller_ updateWindowMediaState:TAB_MEDIA_STATE_AUDIO_MUTING
+                       forWebContents:contents_at_tab0];
+
+  [tabStripControllerForTesting setMediaStateForContents:contents_at_tab1
+                                          withMediaState:TAB_MEDIA_STATE_NONE];
+  [controller_ updateWindowMediaState:TAB_MEDIA_STATE_NONE
+                       forWebContents:contents_at_tab1];
+  // One of the tabs is muting, the other one is none. So window media state
+  // should be MUTING.
+  EXPECT_EQ(TAB_MEDIA_STATE_AUDIO_MUTING, [window_controller mediaState]);
+
+  [tabStripControllerForTesting setMediaStateForContents:contents_at_tab0
+                                          withMediaState:TAB_MEDIA_STATE_NONE];
+  [controller_ updateWindowMediaState:TAB_MEDIA_STATE_NONE
+                       forWebContents:contents_at_tab0];
+  // Neither of tabs playing nor muting, so the window media state should be
+  // NONE.
+  EXPECT_EQ(TAB_MEDIA_STATE_NONE, [window_controller mediaState]);
+}
+
 }  // namespace