Support for loading all default intent services. Necessary to allow editing of defaults from settin…

chrome/browser/intents/web_intents_registry_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/bind.h"
 #include "base/file_util.h"
 #include "base/json/json_file_value_serializer.h"
 #include "base/message_loop.h"
 #include "base/path_service.h"
 #include "base/scoped_temp_dir.h"
@@ skipping 118 matching lines @@
   MessageLoopForUI message_loop_;
   content::TestBrowserThread ui_thread_;
   content::TestBrowserThread db_thread_;
   scoped_refptr<WebDataService> wds_;
   MockExtensionService extension_service_;
   ExtensionSet extensions_;
   WebIntentsRegistry registry_;
   ScopedTempDir temp_dir_;
 };
 
-// Simple consumer for WebIntentsRegistry notifications. Stores result data and
-// terminates UI thread when callback is invoked.
+// Base consumer for WebIntentsRegistry results.
 class TestConsumer {
  public:
-   void OnIntentsQueryDone(
+   // Wait for the UI message loop to terminate - happens when OnIntesQueryDone
+   // is invoked.
+   void WaitForData() {
+     DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+     MessageLoop::current()->Run();
+   }
+};
+
+// Consumer of service lists. Stores result data and
+// terminates UI thread when callback is invoked.
+class ServiceListConsumer : public TestConsumer {
+ public:
+   void Accept(
        const std::vector<webkit_glue::WebIntentServiceData>& services) {
      services_ = services;
 
      DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
      MessageLoop::current()->Quit();
    }
 
-   bool ServicesContains(const webkit_glue::WebIntentServiceData& data) {
+   bool ResultsContain(const webkit_glue::WebIntentServiceData& service) {
      for (size_t i = 0; i < services_.size(); ++i) {
-       if (services_[i] == data)
+       if (services_[i] == service)
          return true;
      }
      return false;
    }
 
-   void OnIntentsDefaultsQueryDone(
-       const DefaultWebIntentService& default_service) {
-     default_ = default_service;
+   // Result data from callback.
+   std::vector<webkit_glue::WebIntentServiceData> services_;
+};
+
+// Consume or defaultservice lists. Stores result data and
+// terminates UI thread when callback is invoked.
+class DefaultServiceListConsumer : public TestConsumer {
+ public:
+   void Accept(const std::vector<DefaultWebIntentService>& services) {
+     services_ = services;
 
      DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
      MessageLoop::current()->Quit();
    }
 
-   // Wait for the UI message loop to terminate - happens when OnIntesQueryDone
-   // is invoked.
-   void WaitForData() {
-     DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
-     MessageLoop::current()->Run();
+   bool ResultsContain(const DefaultWebIntentService& service) {
+     for (size_t i = 0; i < services_.size(); ++i) {
+       if (services_[i] == service)
+         return true;
+     }
+     return false;
    }
 
    // Result data from callback.
-   std::vector<webkit_glue::WebIntentServiceData> services_;
+   std::vector<DefaultWebIntentService> services_;
+};
+
+// Consumer of a default service. Stores result data and
+// terminates UI thread when callback is invoked.
+class DefaultServiceConsumer : public TestConsumer {
+ public:
+   void Accept(
+       const DefaultWebIntentService& default_service) {
+     service_ = default_service;
+
+     DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+     MessageLoop::current()->Quit();
+   }
 
    // Result default data from callback.
-   DefaultWebIntentService default_;
+   DefaultWebIntentService service_;
 };
 
 TEST_F(WebIntentsRegistryTest, BasicTests) {
   webkit_glue::WebIntentServiceData service;
   service.service_url = GURL("http://google.com");
   service.action = ASCIIToUTF16("share");
   service.type = ASCIIToUTF16("image/*");
   service.title = ASCIIToUTF16("Google's Sharing Service");
 
   registry_.RegisterIntentService(service);
 
   service.type = ASCIIToUTF16("video/*");
   service.title = ASCIIToUTF16("Second Service");
   registry_.RegisterIntentService(service);
 
   service.action = ASCIIToUTF16("search");
   registry_.RegisterIntentService(service);
 
-  TestConsumer consumer;
+  ServiceListConsumer consumer;
   registry_.GetIntentServices(ASCIIToUTF16("share"), ASCIIToUTF16("*"),
-                              base::Bind(&TestConsumer::OnIntentsQueryDone,
+                              base::Bind(&ServiceListConsumer::Accept,
                                          base::Unretained(&consumer)));
   consumer.WaitForData();
   EXPECT_EQ(2U, consumer.services_.size());
 
   registry_.GetIntentServices(ASCIIToUTF16("search"), ASCIIToUTF16("*"),
-                              base::Bind(&TestConsumer::OnIntentsQueryDone,
+                              base::Bind(&ServiceListConsumer::Accept,
                                          base::Unretained(&consumer)));
   consumer.WaitForData();
   EXPECT_EQ(1U, consumer.services_.size());
 
   service.action = ASCIIToUTF16("share");
   service.type = ASCIIToUTF16("image/*");
   registry_.UnregisterIntentService(service);
 
   registry_.GetIntentServices(ASCIIToUTF16("share"), ASCIIToUTF16("*"),
-                              base::Bind(&TestConsumer::OnIntentsQueryDone,
+                              base::Bind(&ServiceListConsumer::Accept,
                                          base::Unretained(&consumer)));
   consumer.WaitForData();
   EXPECT_EQ(1U, consumer.services_.size());
 }
 
 TEST_F(WebIntentsRegistryTest, GetIntentServicesForExtensionFilter) {
   scoped_refptr<Extension> share_extension(
       LoadAndExpectSuccess("intent_valid.json"));
   scoped_refptr<Extension> edit_extension(
       LoadAndExpectSuccess("intent_valid_2.json"));
   extensions_.Insert(share_extension);
   extensions_.Insert(edit_extension);
   ASSERT_EQ(2U, extensions_.size());
 
-  TestConsumer consumer;
+  ServiceListConsumer consumer;
   registry_.GetIntentServicesForExtensionFilter(
       ASCIIToUTF16("http://webintents.org/edit"),
       ASCIIToUTF16("image/*"),
       edit_extension->id(),
-      base::Bind(&TestConsumer::OnIntentsQueryDone,
+      base::Bind(&ServiceListConsumer::Accept,
           base::Unretained(&consumer)));
   consumer.WaitForData();
   ASSERT_EQ(1U, consumer.services_.size());
 
   EXPECT_EQ(edit_extension->url().spec() + "services/edit",
             consumer.services_[0].service_url.spec());
 }
 
 TEST_F(WebIntentsRegistryTest, GetAllIntents) {
   webkit_glue::WebIntentServiceData service;
   service.service_url = GURL("http://google.com");
   service.action = ASCIIToUTF16("share");
   service.type = ASCIIToUTF16("image/*");
   service.title = ASCIIToUTF16("Google's Sharing Service");
   registry_.RegisterIntentService(service);
 
   service.action = ASCIIToUTF16("search");
   registry_.RegisterIntentService(service);
 
-  TestConsumer consumer;
-  registry_.GetAllIntentServices(base::Bind(&TestConsumer::OnIntentsQueryDone,
+  ServiceListConsumer consumer;
+  registry_.GetAllIntentServices(base::Bind(&ServiceListConsumer::Accept,
                                             base::Unretained(&consumer)));
   consumer.WaitForData();
   ASSERT_EQ(2U, consumer.services_.size());
 
   if (consumer.services_[0].action != ASCIIToUTF16("share"))
     std::swap(consumer.services_[0],consumer.services_[1]);
 
   service.action = ASCIIToUTF16("share");
   EXPECT_EQ(service, consumer.services_[0]);
 
   service.action = ASCIIToUTF16("search");
   EXPECT_EQ(service, consumer.services_[1]);
 }
 
 TEST_F(WebIntentsRegistryTest, GetExtensionIntents) {
   extensions_.Insert(LoadAndExpectSuccess("intent_valid.json"));
   extensions_.Insert(LoadAndExpectSuccess("intent_valid_2.json"));
   ASSERT_EQ(2U, extensions_.size());
 
-  TestConsumer consumer;
-  registry_.GetAllIntentServices(base::Bind(&TestConsumer::OnIntentsQueryDone,
+  ServiceListConsumer consumer;
+  registry_.GetAllIntentServices(base::Bind(&ServiceListConsumer::Accept,
                                             base::Unretained(&consumer)));
   consumer.WaitForData();
   ASSERT_EQ(2U, consumer.services_.size());
 }
 
 TEST_F(WebIntentsRegistryTest, GetSomeExtensionIntents) {
   extensions_.Insert(LoadAndExpectSuccess("intent_valid.json"));
   extensions_.Insert(LoadAndExpectSuccess("intent_valid_2.json"));
   ASSERT_EQ(2U, extensions_.size());
 
-  TestConsumer consumer;
+  ServiceListConsumer consumer;
   registry_.GetIntentServices(ASCIIToUTF16("http://webintents.org/edit"),
                               ASCIIToUTF16("*"),
-                              base::Bind(&TestConsumer::OnIntentsQueryDone,
+                              base::Bind(&ServiceListConsumer::Accept,
                                          base::Unretained(&consumer)));
   consumer.WaitForData();
   ASSERT_EQ(1U, consumer.services_.size());
 }
 
 TEST_F(WebIntentsRegistryTest, GetIntentsFromMixedSources) {
   extensions_.Insert(LoadAndExpectSuccess("intent_valid.json"));
   extensions_.Insert(LoadAndExpectSuccess("intent_valid_2.json"));
   ASSERT_EQ(2U, extensions_.size());
 
   webkit_glue::WebIntentServiceData service;
   service.service_url = GURL("http://somewhere.com/intent/edit.html");
   service.action = ASCIIToUTF16("http://webintents.org/edit");
   service.type = ASCIIToUTF16("image/*");
   service.title = ASCIIToUTF16("Image Editing Service");
   registry_.RegisterIntentService(service);
 
-  TestConsumer consumer;
+  ServiceListConsumer consumer;
   registry_.GetIntentServices(
       ASCIIToUTF16("http://webintents.org/edit"), ASCIIToUTF16("*"),
-      base::Bind(&TestConsumer::OnIntentsQueryDone,
+      base::Bind(&ServiceListConsumer::Accept,
           base::Unretained(&consumer)));
   consumer.WaitForData();
   ASSERT_EQ(2U, consumer.services_.size());
 
   registry_.GetIntentServices(ASCIIToUTF16("http://webintents.org/share"),
                               ASCIIToUTF16("*"),
-                              base::Bind(&TestConsumer::OnIntentsQueryDone,
+                              base::Bind(&ServiceListConsumer::Accept,
                                          base::Unretained(&consumer)));
   consumer.WaitForData();
   ASSERT_EQ(1U, consumer.services_.size());
 }
 
 TEST_F(WebIntentsRegistryTest, GetIntentsWithMimeAndLiteralMatching) {
   WebIntentServiceData services[] = {
     WebIntentServiceData(ASCIIToUTF16("http://webintents.org/share"),
                          ASCIIToUTF16("image/*"),
                          string16(),
@@ skipping 73 matching lines @@
   registry_.RegisterIntentService(services[5]);
   registry_.RegisterIntentService(services[6]);
   registry_.RegisterIntentService(services[7]);
   registry_.RegisterIntentService(services[8]);
   registry_.RegisterIntentService(services[9]);
   registry_.RegisterIntentService(services[10]);
   registry_.RegisterIntentService(services[11]);
   registry_.RegisterIntentService(services[12]);
   registry_.RegisterIntentService(services[13]);
 
-  TestConsumer consumer;
+  ServiceListConsumer consumer;
 
   // Test specific match on both sides.
   registry_.GetIntentServices(ASCIIToUTF16("http://webintents.org/share"),
                               ASCIIToUTF16("text/uri-list"),
-                              base::Bind(&TestConsumer::OnIntentsQueryDone,
+                              base::Bind(&ServiceListConsumer::Accept,
                                          base::Unretained(&consumer)));
   consumer.WaitForData();
   ASSERT_EQ(1U, consumer.services_.size());
   EXPECT_EQ(services[2], consumer.services_[0]);
 
   // Test specific query, wildcard registration.
   registry_.GetIntentServices(ASCIIToUTF16("http://webintents.org/share"),
                               ASCIIToUTF16("image/png"),
-                              base::Bind(&TestConsumer::OnIntentsQueryDone,
+                              base::Bind(&ServiceListConsumer::Accept,
                                          base::Unretained(&consumer)));
   consumer.WaitForData();
   ASSERT_EQ(1U, consumer.services_.size());
   EXPECT_EQ(services[0], consumer.services_[0]);
 
   // Test wildcard query, specific registration.
   registry_.GetIntentServices(ASCIIToUTF16("http://webintents.org/share"),
                               ASCIIToUTF16("text/*"),
-                              base::Bind(&TestConsumer::OnIntentsQueryDone,
+                              base::Bind(&ServiceListConsumer::Accept,
                                          base::Unretained(&consumer)));
   consumer.WaitForData();
   ASSERT_EQ(2U, consumer.services_.size());
   EXPECT_EQ(services[2], consumer.services_[0]);
   EXPECT_EQ(services[3], consumer.services_[1]);
 
   // Test wildcard query, wildcard registration.
   registry_.GetIntentServices(ASCIIToUTF16("http://webintents.org/share"),
                               ASCIIToUTF16("image/*"),
-                              base::Bind(&TestConsumer::OnIntentsQueryDone,
+                              base::Bind(&ServiceListConsumer::Accept,
                                          base::Unretained(&consumer)));
   consumer.WaitForData();
   ASSERT_EQ(2U, consumer.services_.size());
   EXPECT_EQ(services[0], consumer.services_[0]);
   EXPECT_EQ(services[1], consumer.services_[1]);
 
   // Test "catch-all" query.
   registry_.GetIntentServices(ASCIIToUTF16("http://webintents.org/share"),
                               ASCIIToUTF16("*"),
-                              base::Bind(&TestConsumer::OnIntentsQueryDone,
+                              base::Bind(&ServiceListConsumer::Accept,
                                          base::Unretained(&consumer)));
   consumer.WaitForData();
   ASSERT_EQ(5U, consumer.services_.size());
-  EXPECT_TRUE(consumer.ServicesContains(services[0]));
-  EXPECT_TRUE(consumer.ServicesContains(services[1]));
-  EXPECT_TRUE(consumer.ServicesContains(services[2]));
-  EXPECT_TRUE(consumer.ServicesContains(services[3]));
-  EXPECT_TRUE(consumer.ServicesContains(services[12]));
+  EXPECT_TRUE(consumer.ResultsContain(services[0]));
+  EXPECT_TRUE(consumer.ResultsContain(services[1]));
+  EXPECT_TRUE(consumer.ResultsContain(services[2]));
+  EXPECT_TRUE(consumer.ResultsContain(services[3]));
+  EXPECT_TRUE(consumer.ResultsContain(services[12]));
 
   // Test retrieve string literal match.
   registry_.GetIntentServices(
       ASCIIToUTF16("http://webintents.org/share"), ASCIIToUTF16("elsewhere"),
-      base::Bind(&TestConsumer::OnIntentsQueryDone,
+      base::Bind(&ServiceListConsumer::Accept,
                  base::Unretained(&consumer)));
   consumer.WaitForData();
   ASSERT_EQ(1U, consumer.services_.size());
   EXPECT_EQ(services[4], consumer.services_[0]);
 
   // Test retrieve MIME-looking type but actually isn't
   // doesn't wildcard match.
   registry_.GetIntentServices(
       ASCIIToUTF16("http://webintents.org/share"),
       ASCIIToUTF16("nota/mimetype"),
-      base::Bind(&TestConsumer::OnIntentsQueryDone,
+      base::Bind(&ServiceListConsumer::Accept,
                  base::Unretained(&consumer)));
   consumer.WaitForData();
   ASSERT_EQ(0U, consumer.services_.size());
 
   // Also a MIME-ish type that actually isn't.
   registry_.GetIntentServices(
       ASCIIToUTF16("http://webintents.org/share"),
       ASCIIToUTF16("x-/mimetype"),
-      base::Bind(&TestConsumer::OnIntentsQueryDone,
+      base::Bind(&ServiceListConsumer::Accept,
                  base::Unretained(&consumer)));
   consumer.WaitForData();
   ASSERT_EQ(0U, consumer.services_.size());
 
   // Extension MIME type will match wildcard.
   registry_.GetIntentServices(
       ASCIIToUTF16("http://webintents.org/share"),
       ASCIIToUTF16("x-type/mimetype"),
-      base::Bind(&TestConsumer::OnIntentsQueryDone,
+      base::Bind(&ServiceListConsumer::Accept,
                        base::Unretained(&consumer)));
   consumer.WaitForData();
   ASSERT_EQ(1U, consumer.services_.size());
 }
 
+TEST_F(WebIntentsRegistryTest, TestGetAllDefaultIntentServices) {
+  DefaultWebIntentService s0;
+  s0.action = ASCIIToUTF16("share");
+  s0.type = ASCIIToUTF16("text/*");
+  // Values here are just dummies to test for preservation.
+  s0.user_date = 1;
+  s0.suppression = 4;
+  s0.service_url = "service_url";
+  registry_.RegisterDefaultIntentService(s0);
+
+  DefaultWebIntentService s1;
+  s1.action = ASCIIToUTF16("pick");
+  s1.type = ASCIIToUTF16("image/*");
+  // Values here are just dummies to test for preservation.
+  s1.user_date = 1;
+  s1.suppression = 4;
+  s1.service_url = "service_url";
+  registry_.RegisterDefaultIntentService(s1);
+
+  DefaultWebIntentService s2;
+  s2.action = ASCIIToUTF16("save");
+  s2.type = ASCIIToUTF16("application/*");
+  // Values here are just dummies to test for preservation.
+  s2.user_date = 1;
+  s2.suppression = 4;
+  s2.service_url = "service_url";
+  registry_.RegisterDefaultIntentService(s2);
+
+  DefaultServiceListConsumer consumer;
+
+  // Test we can retrieve default entries by action.
+  registry_.GetAllDefaultIntentServices(
+      base::Bind(&DefaultServiceListConsumer::Accept,
+                 base::Unretained(&consumer)));
+
+  consumer.WaitForData();
+
+  EXPECT_TRUE(consumer.ResultsContain(s0));
+  EXPECT_TRUE(consumer.ResultsContain(s1));
+  EXPECT_TRUE(consumer.ResultsContain(s2));
+}
+
 TEST_F(WebIntentsRegistryTest, TestGetDefaults) {
   DefaultWebIntentService default_service;
   default_service.action = ASCIIToUTF16("share");
   default_service.type = ASCIIToUTF16("text/*");
   // Values here are just dummies to test for preservation.
   default_service.user_date = 1;
   default_service.suppression = 4;
   default_service.service_url = "service_url";
   registry_.RegisterDefaultIntentService(default_service);
 
-  TestConsumer consumer;
+  DefaultServiceConsumer consumer;
 
   // Test we can retrieve default entries by action.
   registry_.GetDefaultIntentService(
       ASCIIToUTF16("share"), ASCIIToUTF16("text/plain"),
       GURL("http://www.google.com/"),
-      base::Bind(&TestConsumer::OnIntentsDefaultsQueryDone,
+      base::Bind(&DefaultServiceConsumer::Accept,
                  base::Unretained(&consumer)));
 
   consumer.WaitForData();
 
-  EXPECT_EQ("service_url", consumer.default_.service_url);
-  EXPECT_EQ(1, consumer.default_.user_date);
-  EXPECT_EQ(4, consumer.default_.suppression);
+  EXPECT_EQ("service_url", consumer.service_.service_url);
+  EXPECT_EQ(1, consumer.service_.user_date);
+  EXPECT_EQ(4, consumer.service_.suppression);
 
   // Test that no action match means we don't retrieve any
   // default entries.
-  consumer.default_ = DefaultWebIntentService();
-  ASSERT_EQ("", consumer.default_.service_url);
+  consumer.service_ = DefaultWebIntentService();
+  ASSERT_EQ("", consumer.service_.service_url);
   registry_.GetDefaultIntentService(
       ASCIIToUTF16("no-share"), ASCIIToUTF16("text/plain"),
       GURL("http://www.google.com/"),
-      base::Bind(&TestConsumer::OnIntentsDefaultsQueryDone,
+      base::Bind(&DefaultServiceConsumer::Accept,
                  base::Unretained(&consumer)));
 
   consumer.WaitForData();
 
-  EXPECT_EQ("", consumer.default_.service_url);
+  EXPECT_EQ("", consumer.service_.service_url);
 
   // Test that no type match means we don't retrieve any
   // default entries (they get filtered out).
-  consumer.default_ = DefaultWebIntentService();
-  ASSERT_EQ("", consumer.default_.service_url);
+  consumer.service_ = DefaultWebIntentService();
+  ASSERT_EQ("", consumer.service_.service_url);
   registry_.GetDefaultIntentService(
       ASCIIToUTF16("share"), ASCIIToUTF16("image/plain"),
       GURL("http://www.google.com/"),
-      base::Bind(&TestConsumer::OnIntentsDefaultsQueryDone,
+      base::Bind(&DefaultServiceConsumer::Accept,
                  base::Unretained(&consumer)));
 
   consumer.WaitForData();
 
-  EXPECT_EQ("", consumer.default_.service_url);
+  EXPECT_EQ("", consumer.service_.service_url);
 
   // Check that a string-literal type won't match.
-  consumer.default_ = DefaultWebIntentService();
-  ASSERT_EQ("", consumer.default_.service_url);
+  consumer.service_ = DefaultWebIntentService();
+  ASSERT_EQ("", consumer.service_.service_url);
   registry_.GetDefaultIntentService(
       ASCIIToUTF16("share"),
       ASCIIToUTF16("literal"),
       GURL("http://www.google.com/"),
-      base::Bind(&TestConsumer::OnIntentsDefaultsQueryDone,
+      base::Bind(&DefaultServiceConsumer::Accept,
                  base::Unretained(&consumer)));
 
   consumer.WaitForData();
 
-  EXPECT_EQ("", consumer.default_.service_url);
+  EXPECT_EQ("", consumer.service_.service_url);
 }
 
 // Verify that collapsing equivalent intents works properly.
 TEST_F(WebIntentsRegistryTest, CollapseIntents) {
   WebIntentsRegistry::IntentServiceList services;
 
   // Add two intents with identical |service_url|, |title|, and |action|.
   services.push_back(
       WebIntentServiceData(ASCIIToUTF16("http://webintents.org/share"),
       ASCIIToUTF16("image/png"),
@@ skipping 64 matching lines @@
                          ASCIIToUTF16("Image Sharing Service")),
     WebIntentServiceData(ASCIIToUTF16("http://webintents.org/share"),
                          ASCIIToUTF16("image/jpg"),
                          string16(),
                          GURL("http://somewhere.com/intent/share.html"),
                          ASCIIToUTF16("Image Sharing Service"))
   };
   registry_.RegisterIntentService(services[0]);
   registry_.RegisterIntentService(services[1]);
 
-  TestConsumer consumer;
+  ServiceListConsumer consumer;
   registry_.GetIntentServices(ASCIIToUTF16("http://webintents.org/share"),
                               ASCIIToUTF16("image/*"),
-                              base::Bind(&TestConsumer::OnIntentsQueryDone,
+                              base::Bind(&ServiceListConsumer::Accept,
                                          base::Unretained(&consumer)));
 
   consumer.WaitForData();
   ASSERT_EQ(1U, consumer.services_.size());
   EXPECT_EQ(ASCIIToUTF16("image/png,image/jpg"), consumer.services_[0].type);
 }