Limit number of service instances passed to onServiceList listeners.

chrome/browser/extensions/api/mdns/mdns_api_unittest.cc

 // Copyright 2015 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/extensions/api/mdns/mdns_api.h"
 #include "chrome/browser/extensions/extension_service.h"
 #include "chrome/browser/extensions/extension_service_test_base.h"
 #include "chrome/browser/extensions/test_extension_system.h"
 #include "chrome/common/extensions/api/mdns.h"
 #include "content/public/browser/browser_context.h"
@@ skipping 45 matching lines @@
     // Set up browser_context().
     InitializeEmptyExtensionService();
 
     // A custom TestingFactoryFunction is required for an MDnsAPI to actually be
     // constructed.
     MDnsAPI::GetFactoryInstance()->SetTestingFactory(
         browser_context(),
         MDnsAPITestingFactoryFunction);
 
     // Create an event router and associate it with the context.
-    extensions::EventRouter* event_router = new extensions::EventRouter(
-        browser_context(),
-        ExtensionPrefsFactory::GetInstance()->GetForBrowserContext(
-            browser_context()));
+    extensions::EventRouter* event_router = CreateEventRouter_();
     static_cast<TestExtensionSystem*>(
         ExtensionSystem::Get(browser_context()))->SetEventRouter(
             scoped_ptr<extensions::EventRouter>(event_router));
 
     // Do some sanity checking
     ASSERT_EQ(event_router, EventRouter::Get(browser_context()));
     ASSERT_TRUE(MDnsAPI::Get(browser_context())); // constructs MDnsAPI
 
     registry_ = new MockDnsSdRegistry(MDnsAPI::Get(browser_context()));
     EXPECT_CALL(*dns_sd_registry(),
@@ skipping 46 matching lines @@
         manifest,
         Extension::NO_FLAGS,
         extension_id,
         &error);
   }
 
   content::RenderProcessHost* render_process_host() const {
     return render_process_host_.get();
   }
 
+ protected:
+  virtual extensions::EventRouter* CreateEventRouter_() {
+    return new extensions::EventRouter(
+        browser_context(),
+        ExtensionPrefsFactory::GetInstance()->GetForBrowserContext(
+            browser_context()));
+  }
+
  private:
   // The registry is owned by MDnsAPI, but MDnsAPI does not have an accessor
   // for it, so use a private member.
   MockDnsSdRegistry* registry_;
 
   scoped_ptr<content::RenderProcessHost> render_process_host_;
 
 };
 
 TEST_F(MDnsAPITest, ExtensionRespectsWhitelist) {
@@ skipping 59 matching lines @@
   EventRouter::Get(browser_context())->AddFilteredEventListener(
       api::mdns::OnServiceList::kEventName, render_process_host(), ext_id,
       filter, false);
 
   EXPECT_CALL(*dns_sd_registry(), UnregisterDnsSdListener("_trex._tcp.local"));
   EventRouter::Get(browser_context())->RemoveFilteredEventListener(
       api::mdns::OnServiceList::kEventName, render_process_host(), ext_id,
       filter, false);
 }
 
+class MockEventRouter : public EventRouter {
+ public:
+  explicit MockEventRouter(content::BrowserContext* browser_context,
+                           ExtensionPrefs* extension_prefs) :
+      EventRouter(browser_context, extension_prefs) {}
+  virtual ~MockEventRouter() {}
+
+  virtual void BroadcastEvent(scoped_ptr<Event> event) {
+    BroadcastEventPtr(event.get());
+  }
+  MOCK_METHOD1(BroadcastEventPtr, void(Event* event));
+};
+
+class MDnsAPIMaxServicesTest : public MDnsAPITest {
+ public:
+  MockEventRouter* event_router() {
+    return static_cast<MockEventRouter*>(EventRouter::Get(browser_context()));
+  }
+ protected:
+  extensions::EventRouter* CreateEventRouter_() override {
+    return new MockEventRouter(
+        browser_context(),
+        ExtensionPrefsFactory::GetInstance()->GetForBrowserContext(
+            browser_context()));
+  }
+};
+
+class EventServiceListSizeMatcher :
+      public testing::MatcherInterface<const Event&> {
+ public:
+  explicit EventServiceListSizeMatcher(size_t expected_size)
+      : expected_size_(expected_size) {}
+
+  virtual bool MatchAndExplain(const Event& e,
+                               testing::MatchResultListener* listener) const {
+    if (e.event_args.get() == nullptr) {
+      *listener << "event.event_arg is null when it shouldn't be";
+      return false;
+    }
+    if (e.event_args->GetSize() != 1) {
+      *listener << "event.event_arg.GetSize() should be 1 but is "
+                << e.event_args->GetSize();
+      return false;
+    }
+    const base::ListValue* services = nullptr;
+    {
+      const base::Value* out;
+      e.event_args->Get(0, &out);
+      services = static_cast<const base::ListValue*>(out);
+    }
+    if (services == nullptr) {
+      *listener << "event's service list argument is not a ListValue";
+      return false;
+    }
+    *listener << "number of services is "
+              << services->GetSize();
+    return static_cast<testing::Matcher<size_t>>(testing::Eq(expected_size_))
+        .MatchAndExplain(services->GetSize(), listener);
+  }
+
+  virtual void DescribeTo(::std::ostream* os) const {
+    *os << "is an onServiceList event where the number of services is "
+        << expected_size_;
+  }
+
+  virtual void DescribeNegationTo(::std::ostream* os) const {
+    *os << "isn't an onServiceList event where the number of services is "
+        << expected_size_;
+  }
+ private:
+  size_t expected_size_;
+};
+
+inline testing::Matcher<const Event&> EventServiceListSize(
+    size_t expected_size) {
+  return MakeMatcher(new EventServiceListSizeMatcher(expected_size));
+}
+
+TEST_F(MDnsAPIMaxServicesTest, OnServiceListDoesNotExceedLimit) {
+  // Get the max number of service instances per event.
+  scoped_refptr<MdnsGetMaxServiceInstancesPerEventFunction> f(
+      new MdnsGetMaxServiceInstancesPerEventFunction);
+  f->Run();
+  int max = -1;
+  EXPECT_EQ(true, f->GetResultList()->GetInteger(0, &max));
+
+  // Dispatch an mDNS event with more service instances than the max, and ensure
+  // that the list is truncated by inspecting the argument to MockEventRouter's
+  // BroadcastEvent method.
+  DnsSdRegistry::DnsSdServiceList services;
+  for (int i=0; i < max + 10; ++i) {
+    services.push_back(DnsSdService());
+  }
+  EXPECT_CALL(
+      *event_router(),
+      BroadcastEventPtr(
+          testing::Pointee(EventServiceListSize(size_t(64)))))
+      .Times(1);
+  dns_sd_registry()->DispatchMDnsEvent("_testing._tcp.local", services);
+}
+
+TEST_F(MDnsAPIMaxServicesTest, MdnsGetMaxServiceInstancesPerEventReturns64) {
+  scoped_refptr<MdnsGetMaxServiceInstancesPerEventFunction> f(
+      new MdnsGetMaxServiceInstancesPerEventFunction);
+  f->Run();
+  EXPECT_TRUE(f->GetResultList());
+  EXPECT_EQ(static_cast<const unsigned long>(1), f->GetResultList()->GetSize());
+  int max = -1;
+  EXPECT_EQ(true, f->GetResultList()->GetInteger(0, &max));
+  EXPECT_EQ(64, max);
+}
+
 } // empty namespace
 
 } // namespace extensions