Clean up error handling logic for extension tab muting

chrome/browser/ui/tabs/tab_utils.h

 // 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.
 
 #ifndef CHROME_BROWSER_UI_TABS_TAB_UTILS_H_
 #define CHROME_BROWSER_UI_TABS_TAB_UTILS_H_
 
 #include <string>
 #include <vector>
-
+#include "base/containers/hash_tables.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/strings/string16.h"
 #include "content/public/browser/web_contents_user_data.h"
 
 class TabStripModel;
 
 namespace content {
 class WebContents;
 }  // namespace content
 
 namespace gfx {
 class Animation;
 class Image;
 }  // namespace gfx
 
 // Media state for a tab.  In reality, more than one of these may apply.  See
 // comments for GetTabMediaStateForContents() below.
 enum TabMediaState {
   TAB_MEDIA_STATE_NONE,
   TAB_MEDIA_STATE_RECORDING,  // Audio/Video being recorded, consumed by tab.
   TAB_MEDIA_STATE_CAPTURING,  // Tab contents being captured.
   TAB_MEDIA_STATE_AUDIO_PLAYING,  // Audible audio is playing from the tab.
   TAB_MEDIA_STATE_AUDIO_MUTING,  // Tab audio is being muted.
 };
 
+enum TabMutedResult {
+  TAB_MUTED_RESULT_NONE,

[miu, 2015/07/15 01:45:55]

Don't need TAB_MUTED_RESULT_NONE.  Also, per my later comment, you probably
don't need TAB_MUTED_RESULT_FAIL_NO_CONTENTS.

[Jared Sohn, 2015/07/15 02:33:34]

The intention was to set a default enum value, but I suppose it isn't needed
since we'll always set it to something.

+  TAB_MUTED_RESULT_SUCCESS,
+  TAB_MUTED_RESULT_FAIL_NOT_ENABLED,
+  TAB_MUTED_RESULT_FAIL_NO_CONTENTS,
+  TAB_MUTED_RESULT_FAIL_TABCAPTURE,
+  TAB_MUTED_RESULT_FAIL_RATE_LIMITED,
+};
+
 namespace chrome {
 
 // String to indicate reason for muted state change (user, capture, extension
 // id, or empty string)
 extern const char kMutedToggleCauseUser[];
 extern const char kMutedToggleCauseCapture[];
 
+// Constants for rate limiting mute updating by extensions
+extern const base::TimeDelta kMuteTokenBucketCost =

[miu, 2015/07/15 01:45:56]

Chromium requirement: Global constants have to be POD types.  So, you'd want to
declare them here as:

  extern const int kMuteTokenBucketCostSeconds;
  extern const int kMuteTokenBucketCapacitySeconds;

Then, in tab_utils.cc:

  const int kMuteTokenBucketCostSeconds = 15;
  const int kMuteTokenBucketCapacitySeconds = 3 * kMuteTokenBucketCostSeconds;

...and when you use the constants and need a TimeDelta:

  cause_info->token_bucket =
      std::min(base::TimeDelta::FromSeconds(kMuteTokenBucketCapacitySeconds),
               cause_info->token_bucket + elapsed_since_last_attempt);

[Jared Sohn, 2015/07/15 02:33:34]

Will make this change.

+    base::TimeDelta::FromSeconds(15);
+extern const base::TimeDelta kMuteTokenBucketCapacity =
+    3 * kMuteTokenBucketCost;
+
+// Token buckets used to rate limit mute updating by extensions
+struct MuteTokenBucketInfo {
+  base::TimeDelta token_bucket;
+  base::TimeTicks last_attempt;
+  MuteTokenBucketInfo() {
+    token_bucket = kMuteTokenBucketCapacity;
+    last_attempt = base::TimeTicks::Now();
+  }
+};
+typedef base::hash_map<std::string, linked_ptr<MuteTokenBucketInfo>>
+    MuteTokenBucketInfoMap;
+
 // Logic to determine which components (i.e., close button, favicon, and media
 // indicator) of a tab should be shown, given current state.  |capacity|
 // specifies how many components can be shown, given available tab width.
 //
 // Precedence rules for deciding what to show when capacity is insufficient to
 // show everything:
 //
 //   Active tab: Always show the close button, then the media indicator, then
 //               the favicon.
 //   Inactive tab: Media indicator, then the favicon, then the close button.
@@ skipping 44 matching lines @@
 base::string16 AssembleTabTooltipText(const base::string16& title,
                                       TabMediaState media_state);
 
 // Returns true if the experimental tab audio mute feature is enabled.
 bool IsTabAudioMutingFeatureEnabled();
 
 // Returns true if audio mute can be activated/deactivated for the given
 // |contents|.
 bool CanToggleAudioMute(content::WebContents* contents);
 
+// Returns true if extension-driven muting is rate limited for a tab
+bool IsTabAudioMutedRateLimited(content::WebContents* contents,
+                                const std::string& cause);
+
 // Indicates whether all audio output from |contents| is muted.
 bool IsTabAudioMuted(content::WebContents* contents);
 
 // Sets whether all audio output from |contents| is muted.
 // Cause is extensionid, kMutedToggleCause constant, or empty string
-void SetTabAudioMuted(content::WebContents* contents,
-                      bool mute,
-                      const std::string& cause);
+TabMutedResult SetTabAudioMuted(content::WebContents* contents,
+                                bool mute,
+                                const std::string& cause);
 
 // Get cause of mute (extensionid, kMutedToggleCause constant, or empty string)
 const std::string& GetTabAudioMutedCause(content::WebContents* contents);
 
 // Returns true if the tabs at the |indices| in |tab_strip| are all muted.
 bool AreAllTabsMuted(const TabStripModel& tab_strip,
                      const std::vector<int>& indices);
 
 }  // namespace chrome
 
 #endif  // CHROME_BROWSER_UI_TABS_TAB_UTILS_H_