Update chrome/ to use scoped_refptr<T>::get() rather than implicit "operator T*"

chrome/browser/extensions/extensions_quota_service_unittest.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 "base/message_loop.h"
 #include "base/process.h"
 #include "base/stl_util.h"
 #include "base/string_util.h"
 #include "chrome/browser/extensions/extension_function.h"
 #include "chrome/browser/extensions/extensions_quota_service.h"
@@ skipping 200 matching lines @@
   // Do the same as above except don't exhaust the 3rd (w.l.o.g) bucket.
   bucket.Reset(k2PerMinute, kStartTime);
   DoMoreThan2PerMinuteFor5Minutes(kStartTime, &lim, &bucket, 3);
   // If the 3rd bucket were exhausted, this would fail (see first test).
   EXPECT_TRUE(lim.Apply(&bucket, kStartTime + TimeDelta::FromMinutes(6)));
 }
 
 TEST_F(ExtensionsQuotaServiceTest, NoHeuristic) {
   scoped_refptr<MockFunction> f(new MockFunction("foo"));
   ListValue args;
-  EXPECT_EQ("", service_->Assess(extension_a_, f, &args, kStartTime));
+  EXPECT_EQ("", service_->Assess(extension_a_, f.get(), &args, kStartTime));
 }
 
 TEST_F(ExtensionsQuotaServiceTest, FrozenHeuristic) {
   scoped_refptr<MockFunction> f(new FrozenMockFunction("foo"));
   ListValue args;
   args.Append(new base::FundamentalValue(1));
-  EXPECT_NE("", service_->Assess(extension_a_, f, &args, kStartTime));
+  EXPECT_NE("", service_->Assess(extension_a_, f.get(), &args, kStartTime));
 }
 
 TEST_F(ExtensionsQuotaServiceTest, SingleHeuristic) {
   scoped_refptr<MockFunction> f(new TimedLimitMockFunction("foo"));
   ListValue args;
   args.Append(new base::FundamentalValue(1));
-  EXPECT_EQ("", service_->Assess(extension_a_, f, &args, kStartTime));
-  EXPECT_EQ("", service_->Assess(extension_a_, f, &args,
-                                 kStartTime + TimeDelta::FromSeconds(10)));
-  EXPECT_NE("", service_->Assess(extension_a_, f, &args,
-              kStartTime + TimeDelta::FromSeconds(15)));
+  EXPECT_EQ("", service_->Assess(extension_a_, f.get(), &args, kStartTime));
+  EXPECT_EQ("",
+            service_->Assess(extension_a_,
+                             f.get(),
+                             &args,
+                             kStartTime + TimeDelta::FromSeconds(10)));
+  EXPECT_NE("",
+            service_->Assess(extension_a_,
+                             f.get(),
+                             &args,
+                             kStartTime + TimeDelta::FromSeconds(15)));
 
   ListValue args2;
   args2.Append(new base::FundamentalValue(1));
   args2.Append(new base::FundamentalValue(2));
-  EXPECT_EQ("", service_->Assess(extension_b_, f, &args2, kStartTime));
-  EXPECT_EQ("", service_->Assess(extension_b_, f, &args2,
-                                 kStartTime + TimeDelta::FromSeconds(10)));
+  EXPECT_EQ("", service_->Assess(extension_b_, f.get(), &args2, kStartTime));
+  EXPECT_EQ("",
+            service_->Assess(extension_b_,
+                             f.get(),
+                             &args2,
+                             kStartTime + TimeDelta::FromSeconds(10)));
 
   TimeDelta peace = TimeDelta::FromMinutes(30);
-  EXPECT_EQ("", service_->Assess(extension_b_, f, &args, kStartTime + peace));
-  EXPECT_EQ("", service_->Assess(
-        extension_b_, f, &args,
-        kStartTime + peace + TimeDelta::FromSeconds(10)));
-  EXPECT_NE("", service_->Assess(extension_b_, f, &args2,
-               kStartTime + peace + TimeDelta::FromSeconds(15)));
+  EXPECT_EQ("",
+            service_->Assess(extension_b_, f.get(), &args, kStartTime + peace));
+  EXPECT_EQ("",
+            service_->Assess(extension_b_,
+                             f.get(),
+                             &args,
+                             kStartTime + peace + TimeDelta::FromSeconds(10)));
+  EXPECT_NE("",
+            service_->Assess(extension_b_,
+                             f.get(),
+                             &args2,
+                             kStartTime + peace + TimeDelta::FromSeconds(15)));
 
   // Test that items are independent.
   ListValue args3;
   args3.Append(new base::FundamentalValue(3));
-  EXPECT_EQ("", service_->Assess(extension_c_, f, &args, kStartTime));
-  EXPECT_EQ("", service_->Assess(extension_c_, f, &args3,
-                                 kStartTime + TimeDelta::FromSeconds(10)));
-  EXPECT_EQ("", service_->Assess(extension_c_, f, &args,
-                                 kStartTime + TimeDelta::FromSeconds(15)));
-  EXPECT_EQ("", service_->Assess(extension_c_, f, &args3,
-                                 kStartTime + TimeDelta::FromSeconds(20)));
-  EXPECT_NE("", service_->Assess(extension_c_, f, &args,
-                                 kStartTime + TimeDelta::FromSeconds(25)));
-  EXPECT_NE("", service_->Assess(extension_c_, f, &args3,
-                                 kStartTime + TimeDelta::FromSeconds(30)));
+  EXPECT_EQ("", service_->Assess(extension_c_, f.get(), &args, kStartTime));
+  EXPECT_EQ("",
+            service_->Assess(extension_c_,
+                             f.get(),
+                             &args3,
+                             kStartTime + TimeDelta::FromSeconds(10)));
+  EXPECT_EQ("",
+            service_->Assess(extension_c_,
+                             f.get(),
+                             &args,
+                             kStartTime + TimeDelta::FromSeconds(15)));
+  EXPECT_EQ("",
+            service_->Assess(extension_c_,
+                             f.get(),
+                             &args3,
+                             kStartTime + TimeDelta::FromSeconds(20)));
+  EXPECT_NE("",
+            service_->Assess(extension_c_,
+                             f.get(),
+                             &args,
+                             kStartTime + TimeDelta::FromSeconds(25)));
+  EXPECT_NE("",
+            service_->Assess(extension_c_,
+                             f.get(),
+                             &args3,
+                             kStartTime + TimeDelta::FromSeconds(30)));
 }
 
 TEST_F(ExtensionsQuotaServiceTest, ChainedHeuristics) {
   scoped_refptr<MockFunction> f(new ChainedLimitsMockFunction("foo"));
   ListValue args;
   args.Append(new base::FundamentalValue(1));
 
   // First, test that the low limit can be avoided but the higher one is hit.
   // One event per minute for 20 minutes comes in under the sustained limit,
   // but is equal to the timed limit.
   for (int i = 0; i < 20; i++) {
-    EXPECT_EQ("", service_->Assess(
-          extension_a_, f, &args,
-          kStartTime + TimeDelta::FromSeconds(10 + i * 60)));
+    EXPECT_EQ(
+        "",
+        service_->Assess(extension_a_,
+                         f.get(),
+                         &args,
+                         kStartTime + TimeDelta::FromSeconds(10 + i * 60)));
   }
 
   // This will bring us to 21 events in an hour, which is a violation.
-  EXPECT_NE("", service_->Assess(extension_a_, f, &args,
-                                 kStartTime + TimeDelta::FromMinutes(30)));
+  EXPECT_NE("",
+            service_->Assess(extension_a_,
+                             f.get(),
+                             &args,
+                             kStartTime + TimeDelta::FromMinutes(30)));
 
   // Now, check that we can still hit the lower limit.
   for (int i = 0; i < 5; i++) {
-    EXPECT_EQ("", service_->Assess(
-          extension_b_, f, &args,
-          kStartTime + TimeDelta::FromSeconds(10 + i * 60)));
-    EXPECT_EQ("", service_->Assess(
-          extension_b_, f, &args,
-          kStartTime + TimeDelta::FromSeconds(15 + i * 60)));
-    EXPECT_EQ("", service_->Assess(
-          extension_b_, f, &args,
-          kStartTime + TimeDelta::FromSeconds(20 + i * 60)));
+    EXPECT_EQ(
+        "",
+        service_->Assess(extension_b_,
+                         f.get(),
+                         &args,
+                         kStartTime + TimeDelta::FromSeconds(10 + i * 60)));
+    EXPECT_EQ(
+        "",
+        service_->Assess(extension_b_,
+                         f.get(),
+                         &args,
+                         kStartTime + TimeDelta::FromSeconds(15 + i * 60)));
+    EXPECT_EQ(
+        "",
+        service_->Assess(extension_b_,
+                         f.get(),
+                         &args,
+                         kStartTime + TimeDelta::FromSeconds(20 + i * 60)));
   }
 
-  EXPECT_NE("", service_->Assess(extension_b_, f, &args,
-               kStartTime + TimeDelta::FromMinutes(6)));
+  EXPECT_NE("",
+            service_->Assess(extension_b_,
+                             f.get(),
+                             &args,
+                             kStartTime + TimeDelta::FromMinutes(6)));
 }
 
 TEST_F(ExtensionsQuotaServiceTest, MultipleFunctionsDontInterfere) {
   scoped_refptr<MockFunction> f(new TimedLimitMockFunction("foo"));
   scoped_refptr<MockFunction> g(new TimedLimitMockFunction("bar"));
 
   ListValue args_f;
   ListValue args_g;
   args_f.Append(new base::FundamentalValue(1));
   args_g.Append(new base::FundamentalValue(2));
 
-  EXPECT_EQ("", service_->Assess(extension_a_, f, &args_f, kStartTime));
-  EXPECT_EQ("", service_->Assess(extension_a_, g, &args_g, kStartTime));
-  EXPECT_EQ("", service_->Assess(extension_a_, f, &args_f,
-                                 kStartTime + TimeDelta::FromSeconds(10)));
-  EXPECT_EQ("", service_->Assess(extension_a_, g, &args_g,
-                                 kStartTime + TimeDelta::FromSeconds(10)));
-  EXPECT_NE("", service_->Assess(extension_a_, f, &args_f,
-                                 kStartTime + TimeDelta::FromSeconds(15)));
-  EXPECT_NE("", service_->Assess(extension_a_, g, &args_g,
-                                 kStartTime + TimeDelta::FromSeconds(15)));
+  EXPECT_EQ("", service_->Assess(extension_a_, f.get(), &args_f, kStartTime));
+  EXPECT_EQ("", service_->Assess(extension_a_, g.get(), &args_g, kStartTime));
+  EXPECT_EQ("",
+            service_->Assess(extension_a_,
+                             f.get(),
+                             &args_f,
+                             kStartTime + TimeDelta::FromSeconds(10)));
+  EXPECT_EQ("",
+            service_->Assess(extension_a_,
+                             g.get(),
+                             &args_g,
+                             kStartTime + TimeDelta::FromSeconds(10)));
+  EXPECT_NE("",
+            service_->Assess(extension_a_,
+                             f.get(),
+                             &args_f,
+                             kStartTime + TimeDelta::FromSeconds(15)));
+  EXPECT_NE("",
+            service_->Assess(extension_a_,
+                             g.get(),
+                             &args_g,
+                             kStartTime + TimeDelta::FromSeconds(15)));
 }
 
 TEST_F(ExtensionsQuotaServiceTest, ViolatorsWillBeViolators) {
   scoped_refptr<MockFunction> f(new TimedLimitMockFunction("foo"));
   scoped_refptr<MockFunction> g(new TimedLimitMockFunction("bar"));
   ListValue arg;
   arg.Append(new base::FundamentalValue(1));
-  EXPECT_EQ("", service_->Assess(extension_a_, f, &arg, kStartTime));
-  EXPECT_EQ("", service_->Assess(extension_a_, f, &arg,
-                                 kStartTime + TimeDelta::FromSeconds(10)));
-  EXPECT_NE("", service_->Assess(extension_a_, f, &arg,
-                                 kStartTime + TimeDelta::FromSeconds(15)));
+  EXPECT_EQ("", service_->Assess(extension_a_, f.get(), &arg, kStartTime));
+  EXPECT_EQ("",
+            service_->Assess(extension_a_,
+                             f.get(),
+                             &arg,
+                             kStartTime + TimeDelta::FromSeconds(10)));
+  EXPECT_NE("",
+            service_->Assess(extension_a_,
+                             f.get(),
+                             &arg,
+                             kStartTime + TimeDelta::FromSeconds(15)));
 
   // We don't allow this extension to use quota limited functions even if they
   // wait a while.
-  EXPECT_NE("", service_->Assess(extension_a_, f, &arg,
-                                 kStartTime + TimeDelta::FromDays(1)));
-  EXPECT_NE("", service_->Assess(extension_a_, g, &arg,
-                                 kStartTime + TimeDelta::FromDays(1)));
+  EXPECT_NE(
+      "",
+      service_->Assess(
+          extension_a_, f.get(), &arg, kStartTime + TimeDelta::FromDays(1)));
+  EXPECT_NE(
+      "",
+      service_->Assess(
+          extension_a_, g.get(), &arg, kStartTime + TimeDelta::FromDays(1)));
 }