[Web Intents] Inline installation of extensions in web intents picker.

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/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"
 #include "base/utf_string_conversions.h"
 #include "chrome/browser/extensions/test_extension_service.h"
 #include "chrome/browser/intents/default_web_intent_service.h"
 #include "chrome/browser/intents/web_intents_registry.h"
 #include "chrome/browser/webdata/web_data_service.h"
 #include "chrome/common/chrome_paths.h"
 #include "chrome/common/extensions/extension_set.h"
 #include "content/test/test_browser_thread.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using content::BrowserThread;
 using webkit_glue::WebIntentServiceData;
 
 class MockExtensionService: public TestExtensionService {
  public:
   virtual ~MockExtensionService() {}
   MOCK_CONST_METHOD0(extensions, const ExtensionSet*());
+  MOCK_CONST_METHOD2(GetExtensionById,
+                     const Extension*(const std::string&, bool));
 };
 
 namespace {
 
 // TODO(groby): Unify loading functions with extension_manifest_unittest code.
 DictionaryValue* LoadManifestFile(const FilePath& path,
                                   std::string* error) {
   EXPECT_TRUE(file_util::PathExists(path));
   JSONFileValueSerializer serializer(path);
   return static_cast<DictionaryValue*>(serializer.Deserialize(NULL, error));
@@ skipping 48 matching lines @@
   virtual void SetUp() {
     CommandLine::ForCurrentProcess()->AppendSwitch("--enable-web-intents");
 
     db_thread_.Start();
     wds_ = new WebDataService();
     ASSERT_TRUE(temp_dir_.CreateUniqueTempDir());
     wds_->Init(temp_dir_.path());
     registry_.Initialize(wds_, &extension_service_);
     EXPECT_CALL(extension_service_, extensions()).
         WillRepeatedly(testing::Return(&extensions_));
+    EXPECT_CALL(extension_service_, GetExtensionById(testing::_, testing::_)).
+        WillRepeatedly(
+            testing::Invoke(this, &WebIntentsRegistryTest::GetExtensionById));
   }
 
   virtual void TearDown() {
     if (wds_.get())
       wds_->Shutdown();
 
     db_thread_.Stop();
     MessageLoop::current()->PostTask(FROM_HERE, MessageLoop::QuitClosure());
     MessageLoop::current()->Run();
   }
 
+  const Extension* GetExtensionById(const std::string& extension_id,
+                                    testing::Unused) {
+    for (ExtensionSet::const_iterator iter = extensions_.begin();
+         iter != extensions_.end(); ++iter) {
+      if ((*iter)->id() == extension_id)
+        return &**iter;
+    }
+
+    return NULL;
+  }
+
   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_;
 };
 
@@ skipping 70 matching lines @@
   service.type = ASCIIToUTF16("image/*");
   registry_.UnregisterIntentService(service);
 
   consumer.expected_id_ = registry_.GetIntentServices(ASCIIToUTF16("share"),
                                                        ASCIIToUTF16("*"),
                                                        &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;
+  consumer.expected_id_ = registry_.GetIntentServicesForExtensionFilter(
+      ASCIIToUTF16("http://webintents.org/edit"),
+      ASCIIToUTF16("image/*"),
+      edit_extension->id(),
+      &consumer);
+  consumer.WaitForData();
+  ASSERT_EQ(1U, consumer.services_.size());
+}
+
 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);
@@ skipping 181 matching lines @@
   consumer.expected_id_ = registry_.GetDefaultIntentService(
       ASCIIToUTF16("share"),
       ASCIIToUTF16("notype/plain"),
       GURL("http://www.google.com/"),
       &consumer);
 
   consumer.WaitForData();
 
   EXPECT_EQ("", consumer.default_.service_url);
 }