bluetooth: Show tab indicator when BT device is connected

chrome/browser/ui/tabs/tab_utils.cc

 // 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.
 
 #include "chrome/browser/ui/tabs/tab_utils.h"
 
 #include <utility>
 
 #include "base/command_line.h"
 #include "base/strings/string16.h"
@@ skipping 141 matching lines @@
   scoped_refptr<MediaStreamCaptureIndicator> indicator =
       MediaCaptureDevicesDispatcher::GetInstance()->
           GetMediaStreamCaptureIndicator();
   if (indicator.get()) {
     if (indicator->IsBeingMirrored(contents))
       return TAB_MEDIA_STATE_CAPTURING;
     if (indicator->IsCapturingUserMedia(contents))
       return TAB_MEDIA_STATE_RECORDING;
   }
 
+  if (contents->IsBluetoothDeviceConnected())
+    return TAB_MEDIA_STATE_BLUETOOTH_CONNECTED;
+
   if (contents->IsAudioMuted())
     return TAB_MEDIA_STATE_AUDIO_MUTING;
   if (contents->WasRecentlyAudible())
     return TAB_MEDIA_STATE_AUDIO_PLAYING;
 
   return TAB_MEDIA_STATE_NONE;
 }
 
 gfx::Image GetTabMediaIndicatorImage(TabMediaState media_state,
                                      SkColor button_color) {
 #if defined(OS_MACOSX)
   ui::ResourceBundle* rb = &ui::ResourceBundle::GetSharedInstance();
   switch (media_state) {
     case TAB_MEDIA_STATE_AUDIO_PLAYING:
       return rb->GetNativeImageNamed(IDR_TAB_AUDIO_INDICATOR);
     case TAB_MEDIA_STATE_AUDIO_MUTING:
       return rb->GetNativeImageNamed(IDR_TAB_AUDIO_MUTING_INDICATOR);
     case TAB_MEDIA_STATE_RECORDING:
       return rb->GetNativeImageNamed(IDR_TAB_RECORDING_INDICATOR);
     case TAB_MEDIA_STATE_CAPTURING:
       return rb->GetNativeImageNamed(IDR_TAB_CAPTURE_INDICATOR);
+    case TAB_MEDIA_STATE_BLUETOOTH_CONNECTED:
+      return rb->GetNativeImageNamed(IDR_TAB_BLUETOOTH_INDICATOR);
     case TAB_MEDIA_STATE_NONE:
       break;
   }
 #else
   gfx::VectorIconId icon_id = gfx::VectorIconId::VECTOR_ICON_NONE;
   switch (media_state) {
     case TAB_MEDIA_STATE_AUDIO_PLAYING:
       icon_id = gfx::VectorIconId::TAB_AUDIO;
       break;
     case TAB_MEDIA_STATE_AUDIO_MUTING:
       icon_id = gfx::VectorIconId::TAB_AUDIO_MUTING;
       break;
     case TAB_MEDIA_STATE_RECORDING:
       icon_id = gfx::VectorIconId::TAB_MEDIA_RECORDING;
       break;
     case TAB_MEDIA_STATE_CAPTURING:
       icon_id = gfx::VectorIconId::TAB_MEDIA_CAPTURING;
       break;
+    case TAB_MEDIA_STATE_BLUETOOTH_CONNECTED:
+      icon_id = gfx::VectorIconId::TAB_BLUETOOTH_CONNECTED;
+      break;
     case TAB_MEDIA_STATE_NONE:
       break;
   }
   if (icon_id != gfx::VectorIconId::VECTOR_ICON_NONE)
     return gfx::Image(gfx::CreateVectorIcon(icon_id, 16, button_color));
 #endif
   NOTREACHED();
   return gfx::Image();
 }
 
 gfx::Image GetTabMediaIndicatorAffordanceImage(TabMediaState media_state,
                                                SkColor button_color) {
   switch (media_state) {
     case TAB_MEDIA_STATE_AUDIO_PLAYING:
       return GetTabMediaIndicatorImage(TAB_MEDIA_STATE_AUDIO_MUTING,
                                        button_color);
     case TAB_MEDIA_STATE_AUDIO_MUTING:
     case TAB_MEDIA_STATE_NONE:
     case TAB_MEDIA_STATE_RECORDING:
     case TAB_MEDIA_STATE_CAPTURING:
+    case TAB_MEDIA_STATE_BLUETOOTH_CONNECTED:
       return GetTabMediaIndicatorImage(media_state, button_color);
   }
   NOTREACHED();
   return GetTabMediaIndicatorImage(media_state, button_color);
 }
 
 scoped_ptr<gfx::Animation> CreateTabMediaIndicatorFadeAnimation(
     TabMediaState media_state) {
   if (media_state == TAB_MEDIA_STATE_RECORDING ||
       media_state == TAB_MEDIA_STATE_CAPTURING) {
@@ skipping 33 matching lines @@
           l10n_util::GetStringUTF16(IDS_TOOLTIP_TAB_MEDIA_STATE_AUDIO_MUTING));
       break;
     case TAB_MEDIA_STATE_RECORDING:
       result.append(
           l10n_util::GetStringUTF16(IDS_TOOLTIP_TAB_MEDIA_STATE_RECORDING));
       break;
     case TAB_MEDIA_STATE_CAPTURING:
       result.append(
           l10n_util::GetStringUTF16(IDS_TOOLTIP_TAB_MEDIA_STATE_CAPTURING));
       break;
+    case TAB_MEDIA_STATE_BLUETOOTH_CONNECTED:
+      result.append(
+          l10n_util::GetStringUTF16(IDS_TOOLTIP_TAB_BLUETOOTH_CONNECTED));
+      break;
     case TAB_MEDIA_STATE_NONE:
       NOTREACHED();
       break;
   }
   return result;
 }
 
 bool AreExperimentalMuteControlsEnabled() {
   return base::CommandLine::ForCurrentProcess()->HasSwitch(
       switches::kEnableTabAudioMuting);
 }
 
 bool CanToggleAudioMute(content::WebContents* contents) {
   switch (GetTabMediaStateForContents(contents)) {
     case TAB_MEDIA_STATE_NONE:
     case TAB_MEDIA_STATE_AUDIO_PLAYING:
     case TAB_MEDIA_STATE_AUDIO_MUTING:
       return true;
     case TAB_MEDIA_STATE_RECORDING:
     case TAB_MEDIA_STATE_CAPTURING:
+    case TAB_MEDIA_STATE_BLUETOOTH_CONNECTED:
       return false;
   }
   NOTREACHED();
   return false;
 }
 
 TabMutedReason GetTabAudioMutedReason(content::WebContents* contents) {
   LastMuteMetadata::CreateForWebContents(contents);  // Ensures metadata exists.
   LastMuteMetadata* const metadata =
       LastMuteMetadata::FromWebContents(contents);
@@ skipping 57 matching lines @@
                      const std::vector<int>& indices) {
   for (std::vector<int>::const_iterator i = indices.begin(); i != indices.end();
        ++i) {
     if (!tab_strip.GetWebContentsAt(*i)->IsAudioMuted())
       return false;
   }
   return true;
 }
 
 }  // namespace chrome