Fix the links in the media bubble pointing to the media UI.

chrome/browser/ui/content_settings/content_setting_bubble_model.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/content_settings/content_setting_bubble_model.h"
 
 #include "base/command_line.h"
 #include "base/prefs/pref_service.h"
 #include "base/strings/utf_string_conversions.h"
 #include "chrome/browser/chrome_notification_types.h"
@@ skipping 560 matching lines @@
 // The model of the content settings bubble for media settings.
 class ContentSettingMediaStreamBubbleModel
     : public ContentSettingTitleAndLinkModel {
  public:
   ContentSettingMediaStreamBubbleModel(Delegate* delegate,
                                        WebContents* web_contents,
                                        Profile* profile);
 
   ~ContentSettingMediaStreamBubbleModel() override;
 
+  void OnManageLinkClicked() override;
+
  private:
   void SetTitle();
   // Sets the data for the radio buttons of the bubble.
   void SetRadioGroup();
   // Sets the data for the media menus of the bubble.
   void SetMediaMenus();
+  // Set the settings management link.
+  void SetManageLink();
   void SetCustomLink();
   // Updates the camera and microphone setting with the passed |setting|.
   void UpdateSettings(ContentSetting setting);
   // Updates the camera and microphone default device with the passed |type|
   // and device.
   void UpdateDefaultDeviceForType(content::MediaStreamType type,
                                   const std::string& device);
 
   // ContentSettingBubbleModel implementation.
   void OnRadioClicked(int radio_index) override;
@@ skipping 10 matching lines @@
 };
 
 ContentSettingMediaStreamBubbleModel::ContentSettingMediaStreamBubbleModel(
     Delegate* delegate,
     WebContents* web_contents,
     Profile* profile)
     : ContentSettingTitleAndLinkModel(
           delegate, web_contents, profile, CONTENT_SETTINGS_TYPE_MEDIASTREAM),
       selected_item_(0),
       state_(TabSpecificContentSettings::MICROPHONE_CAMERA_NOT_ACCESSED) {
+  // TODO(msramek): Every bubble is tied to a particular content setting.
+  // The media bubble has three states - mic only, camera only, and both.
+  // However, it is always tied to the deprecated MEDIASTREAM setting. Refactor
+  // this so that it refers to the MIC setting for microphone and CAMERA
+  // setting for camera to reduce the duplication of code in practically every
+  // method. Furthermore, it should be possible not to tie the bubble to any
+  // particular content setting type, as we still need the bubble for both
+  // camera and microphone, but should not use the deprecated MEDIASTREAM
+  // setting.
+
   DCHECK(profile);
   // Initialize the content settings associated with the individual radio
   // buttons.
   radio_item_setting_[0] = CONTENT_SETTING_ASK;
   radio_item_setting_[1] = CONTENT_SETTING_BLOCK;
 
   TabSpecificContentSettings* content_settings =
       TabSpecificContentSettings::FromWebContents(web_contents);
   state_ = content_settings->GetMicrophoneCameraState();
   DCHECK(state_ & (TabSpecificContentSettings::MICROPHONE_ACCESSED |
                    TabSpecificContentSettings::CAMERA_ACCESSED));
 
   SetTitle();
   SetRadioGroup();
   SetMediaMenus();
+  SetManageLink();
   SetCustomLink();
 }
 
 ContentSettingMediaStreamBubbleModel::~ContentSettingMediaStreamBubbleModel() {
   // On some platforms (e.g. MacOS X) it is possible to close a tab while the
   // media stream bubble is open. This resets the web contents to NULL.
   if (!web_contents())
     return;
 
   for (const std::pair<content::MediaStreamType, MediaMenu>& media_menu :
        bubble_content().media_menus) {
     if (media_menu.second.selected_device.id !=
         media_menu.second.default_device.id) {
       UpdateDefaultDeviceForType(media_menu.first,
                                  media_menu.second.selected_device.id);
     }
   }
 
   // Update the media settings if the radio button selection was changed.
   if (selected_item_ != bubble_content().radio_group.default_item) {
     UpdateSettings(radio_item_setting_[selected_item_]);
   }
 }
 
+void ContentSettingMediaStreamBubbleModel::OnManageLinkClicked() {
+  if (!delegate())
+    return;
+
+  if (state_ & TabSpecificContentSettings::MICROPHONE_ACCESSED) {
+    delegate()->ShowContentSettingsPage(
+        state_ & TabSpecificContentSettings::CAMERA_ACCESSED
+            ? CONTENT_SETTINGS_TYPE_MEDIASTREAM
+            : CONTENT_SETTINGS_TYPE_MEDIASTREAM_MIC);
+  } else {
+    delegate()->ShowContentSettingsPage(
+        CONTENT_SETTINGS_TYPE_MEDIASTREAM_CAMERA);
+  }
+}
+
 void ContentSettingMediaStreamBubbleModel::SetTitle() {
   DCHECK_NE(TabSpecificContentSettings::MICROPHONE_CAMERA_NOT_ACCESSED, state_);
   int title_id = 0;
   if (state_ & TabSpecificContentSettings::MICROPHONE_BLOCKED) {
     title_id = (state_ & TabSpecificContentSettings::CAMERA_BLOCKED) ?
         IDS_MICROPHONE_CAMERA_BLOCKED : IDS_MICROPHONE_BLOCKED;
   } else if (state_ & TabSpecificContentSettings::CAMERA_BLOCKED) {
     title_id = IDS_CAMERA_BLOCKED;
   } else if (state_ & TabSpecificContentSettings::MICROPHONE_ACCESSED) {
     title_id = (state_ & TabSpecificContentSettings::CAMERA_ACCESSED) ?
@@ skipping 11 matching lines @@
   RadioGroup radio_group;
   radio_group.url = url;
 
   base::string16 display_host_utf16 =
       secure_display::FormatUrlForSecurityDisplay(
           url, profile()->GetPrefs()->GetString(prefs::kAcceptLanguages));
   std::string display_host(base::UTF16ToUTF8(display_host_utf16));
   if (display_host.empty())
     display_host = url.spec();
 
   bool is_mic = (state_ & TabSpecificContentSettings::MICROPHONE_ACCESSED) != 0;

[msw, 2015/07/30 17:15:27]

nit: These could be helper functions used instead of repeated lengthy checks.

[msramek, 2015/07/31 12:34:52]

That's one of the things I wanted to leave for that future refactoring :) I
replaced the occurrences with helper functions, but now it's a bit inconsistent
that we check which devices were accessed using the helper functions, but which
ones were blocked using the mask.

I think I'll take the same approach to refactoring this as in
ContentSettingsHandler::MediaSettingsInfo. But let me do that in a follow-up CL
:)

   bool is_cam = (state_ & TabSpecificContentSettings::CAMERA_ACCESSED) != 0;
   DCHECK(is_mic || is_cam);
   int radio_allow_label_id = 0;
   int radio_block_label_id = 0;
   if (state_ & (TabSpecificContentSettings::MICROPHONE_BLOCKED |
                 TabSpecificContentSettings::CAMERA_BLOCKED)) {
     if (content::IsOriginSecure(url)) {
       radio_item_setting_[0] = CONTENT_SETTING_ALLOW;
       radio_allow_label_id = IDS_BLOCKED_MEDIASTREAM_CAMERA_ALLOW;
       if (is_mic)
@@ skipping 140 matching lines @@
       }
 
       camera_menu.default_device =
           GetMediaDeviceById(preferred_camera, cameras);
       camera_menu.selected_device = camera_menu.default_device;
     }
     add_media_menu(content::MEDIA_DEVICE_VIDEO_CAPTURE, camera_menu);
   }
 }
 
+void ContentSettingMediaStreamBubbleModel::SetManageLink() {
+  // By default, the manage link refers to both media types. We only need
+  // to change the text if only one media type was accessed.

[msw, 2015/07/30 17:15:27]

nit: s/text/link/

[msramek, 2015/07/31 12:34:52]

Actually, I wanted to emphasize that here we're changing the text of the link,
as opposed to the internal url it points to.

[msw, 2015/07/31 17:36:04]

Acknowledged.

+  if ((state_ & TabSpecificContentSettings::MICROPHONE_ACCESSED) &&
+      (state_ & TabSpecificContentSettings::CAMERA_ACCESSED)) {
+    return;
+  }
+
+  set_manage_link(state_ & TabSpecificContentSettings::MICROPHONE_ACCESSED
+                      ? l10n_util::GetStringUTF8(

[msw, 2015/07/30 17:15:27]

nit: put the trinary within l10n_util::GetStringUTF8(

[msramek, 2015/07/31 12:34:52]

Done.

+                            IDS_MEDIASTREAM_MICROPHONE_BUBBLE_MANAGE_LINK)
+                      : l10n_util::GetStringUTF8(
+                            IDS_MEDIASTREAM_CAMERA_BUBBLE_MANAGE_LINK));
+}
+
 void ContentSettingMediaStreamBubbleModel::SetCustomLink() {
   TabSpecificContentSettings* content_settings =
       TabSpecificContentSettings::FromWebContents(web_contents());
   if (content_settings->IsMicrophoneCameraStateChanged()) {
     set_custom_link(l10n_util::GetStringUTF8(
         IDS_MEDIASTREAM_SETTING_CHANGED_MESSAGE));
   }
 }
 
 void ContentSettingMediaStreamBubbleModel::OnRadioClicked(int radio_index) {
@@ skipping 441 matching lines @@
   if (type == content::NOTIFICATION_WEB_CONTENTS_DESTROYED) {
     DCHECK_EQ(web_contents_,
               content::Source<WebContents>(source).ptr());
     web_contents_ = NULL;
   } else {
     DCHECK_EQ(chrome::NOTIFICATION_PROFILE_DESTROYED, type);
     DCHECK_EQ(profile_, content::Source<Profile>(source).ptr());
     profile_ = NULL;
   }
 }