Clean up error handling logic for extension tab muting

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 "base/command_line.h"
 #include "base/strings/string16.h"
 #include "chrome/browser/media/media_capture_devices_dispatcher.h"
 #include "chrome/browser/media/media_stream_capture_indicator.h"
 #include "chrome/browser/ui/tabs/tab_strip_model.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/grit/generated_resources.h"
 #include "content/public/browser/web_contents.h"
 #include "grit/theme_resources.h"
 #include "ui/base/l10n/l10n_util.h"
 #include "ui/base/resource/resource_bundle.h"
 #include "ui/gfx/animation/multi_animation.h"
 
 struct LastMuteMetadata
     : public content::WebContentsUserData<LastMuteMetadata> {
   std::string cause;  // Extension ID or constant from header file
                       // or empty string
+  base::TimeDelta token_bucket;
+  base::TimeTicks last_attempt;
+
  private:
-  explicit LastMuteMetadata(content::WebContents* contents) {}
+  explicit LastMuteMetadata(content::WebContents* contents) {
+    token_bucket =
+        base::TimeDelta::FromSeconds(chrome::kMuteTokenBucketCapacitySeconds);
+    last_attempt = base::TimeTicks::Now();
+  }
   friend class content::WebContentsUserData<LastMuteMetadata>;
 };
 
 DEFINE_WEB_CONTENTS_USER_DATA_KEY(LastMuteMetadata);
 
 namespace chrome {
 
 const char kMutedToggleCauseUser[] = "user";
 const char kMutedToggleCauseCapture[] = "capture";
+const int kMuteTokenBucketCostSeconds = 15;
+const int kMuteTokenBucketCapacitySeconds = 3 * kMuteTokenBucketCostSeconds;
 
 namespace {
 
 // Interval between frame updates of the tab indicator animations.  This is not
 // the usual 60 FPS because a trade-off must be made between tab UI animation
 // smoothness and media recording/playback performance on low-end hardware.
 const int kIndicatorFrameIntervalMs = 50;  // 20 FPS
 
 // Fade-in/out duration for the tab indicator animations.  Fade-in is quick to
 // immediately notify the user.  Fade-out is more gradual, so that the user has
@@ skipping 39 matching lines @@
         gfx::Tween::EASE_IN));
   }
   const base::TimeDelta interval =
       base::TimeDelta::FromMilliseconds(kIndicatorFrameIntervalMs);
   scoped_ptr<TabRecordingIndicatorAnimation> animation(
       new TabRecordingIndicatorAnimation(parts, interval));
   animation->set_continuous(false);
   return animation.Pass();
 }
 
+// Only run when cause should be rate limited (i.e. extensions)
+void UpdateTokenBuckets(content::WebContents* contents) {
+  DCHECK(contents);

[miu, 2015/07/18 00:42:42]

To answer your question: The DCHECK here and at the top of
IsTabAudioMutedRateLimited() aren't strictly needed, but they are documentative.
 It's up to you whether to keep them or not.

[Jared Sohn, 2015/07/18 23:57:24]

I am removing them and replacing with a general comment since the current code
just says it cannot be a null pointer but doesn't say that it has initialized
LastMutedMetadata. 

On 2015/07/18 at 00:42:42, miu wrote:

+
+  base::TimeTicks now = base::TimeTicks::Now();
+  base::TimeDelta elapsed_since_last_attempt =
+      now - LastMuteMetadata::FromWebContents(contents)->last_attempt;
+  LastMuteMetadata::FromWebContents(contents)->last_attempt = now;
+
+  // Add tokens to the bucket, proportional to how much time has elapsed, capped
+  // at the maximum capacity.
+  LastMuteMetadata::FromWebContents(contents)->token_bucket = std::min(
+      base::TimeDelta::FromSeconds(chrome::kMuteTokenBucketCapacitySeconds),
+      LastMuteMetadata::FromWebContents(contents)->token_bucket +
+          elapsed_since_last_attempt);
+}
+
+// Only run when cause should be rate limited (i.e. extensions)
+bool IsTabAudioMutedRateLimited(content::WebContents* contents) {
+  DCHECK(contents);
+
+  return (LastMuteMetadata::FromWebContents(contents)->token_bucket <
+          base::TimeDelta::FromSeconds(kMuteTokenBucketCostSeconds));
+}
+
 }  // namespace
 
 bool ShouldTabShowFavicon(int capacity,
                           bool is_pinned_tab,
                           bool is_active_tab,
                           bool has_favicon,
                           TabMediaState media_state) {
   if (!has_favicon)
     return false;
   int required_capacity = 1;
@@ skipping 165 matching lines @@
 const std::string& GetTabAudioMutedCause(content::WebContents* contents) {
   LastMuteMetadata::CreateForWebContents(contents);  // Create if not exists.
   if (GetTabMediaStateForContents(contents) == TAB_MEDIA_STATE_CAPTURING) {
     // For tab capture, libcontent forces muting off.
     LastMuteMetadata::FromWebContents(contents)->cause =
         kMutedToggleCauseCapture;
   }
   return LastMuteMetadata::FromWebContents(contents)->cause;
 }
 
-void SetTabAudioMuted(content::WebContents* contents,
-                      bool mute,
-                      const std::string& cause) {
-  if (!contents || !chrome::CanToggleAudioMute(contents))
-    return;
+TabMutedResult SetTabAudioMuted(content::WebContents* contents,
+                                bool mute,
+                                const std::string& cause) {
+  DCHECK(contents);
+
+  if (!IsTabAudioMutingFeatureEnabled())
+    return TAB_MUTED_RESULT_FAIL_NOT_ENABLED;
+
+  if (!chrome::CanToggleAudioMute(contents))
+    return TAB_MUTED_RESULT_FAIL_TABCAPTURE;
 
   LastMuteMetadata::CreateForWebContents(contents);  // Create if not exists.
+
+  if ((cause != kMutedToggleCauseUser) && (cause != kMutedToggleCauseCapture)) {
+    UpdateTokenBuckets(contents);
+
+    if (IsTabAudioMutedRateLimited(contents))
+      return TAB_MUTED_RESULT_FAIL_RATE_LIMITED;
+
+    LastMuteMetadata::FromWebContents(contents)->token_bucket -=
+        base::TimeDelta::FromSeconds(kMuteTokenBucketCostSeconds);
+  }
+
   LastMuteMetadata::FromWebContents(contents)->cause = cause;
 
   contents->SetAudioMuted(mute);
+
+  return TAB_MUTED_RESULT_SUCCESS;
 }
 
 bool IsTabAudioMuted(content::WebContents* contents) {
   return contents && contents->IsAudioMuted();
 }
 
 bool AreAllTabsMuted(const TabStripModel& tab_strip,
                      const std::vector<int>& indices) {
   for (std::vector<int>::const_iterator i = indices.begin(); i != indices.end();
        ++i) {
     if (!IsTabAudioMuted(tab_strip.GetWebContentsAt(*i)))
       return false;
   }
   return true;
 }
 
 }  // namespace chrome