[Web Intents] WebIntentsPickerController will now fetch icon for suggested extensions.

chrome/browser/ui/intents/web_intent_picker_controller_browsertest.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 <algorithm>
+
 #include "base/bind.h"
 #include "base/callback.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/stringprintf.h"
 #include "base/utf_string_conversions.h"
 #include "chrome/browser/favicon/favicon_service.h"
 #include "chrome/browser/intents/web_intents_registry.h"
 #include "chrome/browser/intents/web_intents_registry_factory.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/ui/browser.h"
 #include "chrome/browser/ui/intents/web_intent_picker.h"
 #include "chrome/browser/ui/intents/web_intent_picker_controller.h"
 #include "chrome/browser/ui/intents/web_intent_picker_model.h"
 #include "chrome/browser/ui/intents/web_intent_picker_model_observer.h"
 #include "chrome/browser/ui/tab_contents/tab_contents_wrapper.h"
 #include "chrome/browser/webdata/web_data_service.h"
 #include "chrome/common/url_constants.h"
 #include "chrome/test/base/in_process_browser_test.h"
 #include "chrome/test/base/ui_test_utils.h"
 #include "content/public/browser/web_contents.h"
 #include "content/public/browser/web_intents_dispatcher.h"
 #include "content/test/test_url_fetcher_factory.h"
+#include "net/base/escape.h"
 #include "testing/gtest/include/gtest/gtest.h"
+#include "ui/gfx/image/image_unittest_util.h"
+#include "ui/gfx/image/image_util.h"
 #include "webkit/glue/web_intent_service_data.h"
 
 namespace {
 
 const string16 kAction1(ASCIIToUTF16("http://www.example.com/share"));
 const string16 kAction2(ASCIIToUTF16("http://www.example.com/foobar"));
 const string16 kType(ASCIIToUTF16("image/png"));
 const GURL kServiceURL1("http://www.google.com");
 const GURL kServiceURL2("http://www.chromium.org");
 const char kCWSResponseEmpty[] =
@@ skipping 30 matching lines @@
         "  \\\"intents\\\": {\\n    "
           "\\\"%s\\\" : {\\n      "
             "\\\"type\\\" : [\\\"%s\\\"],\\n      "
             "\\\"path\\\" : \\\"//services/edit\\\",\\n      "
             "\\\"title\\\" : \\\"Sample Editing Intent\\\",\\n      "
             "\\\"disposition\\\" : \\\"inline\\\"\\n    "
           "}\\n  "
         "}\\n"
       "}\\n\","
       "\"family_safe\":true,"
-      "\"icon_url\":" "\"http://qa-lighthouse.sandbox.google.com/image/"
-          "QzPnRCYCBbBGI99ZkGxkp-NNJ488IkkiTyCgynFEeDTJHcw4tHl3csmjTQ\"}]}";
+      "\"icon_url\": \"%s\"}]}";
+
+const char kCWSFakeIconURLFormat[] = "http://example.com/%s/icon.png";
+
+class DummyURLFetcherFactory : public content::URLFetcherFactory {

[Greg Billock, 2012/02/23 18:38:34]

Would this factory be worth putting in the TestURLFetcher class? Seems like a
useful machine.

[binji, 2012/02/23 19:06:13]

Maybe. The only reason I need it is because I use FakeURLFetcherFactory in a
browser_test, which no-one else does really. More often you see
TestURLFetcherFactory, which  works without it. It's trickier for me to use that
here because it requires a lot more modification to the picker controller and
CWS intents registry to use.

+ public:
+   DummyURLFetcherFactory() {}
+   virtual ~DummyURLFetcherFactory() {}
+
+   virtual content::URLFetcher* CreateURLFetcher(
+       int id,
+       const GURL& url,
+       content::URLFetcher::RequestType request_type,
+       content::URLFetcherDelegate* d) OVERRIDE {
+     return new TestURLFetcher(id, url, d);
+   }
+};
 
 }  // namespace
 
 class WebIntentPickerMock : public WebIntentPicker,
                             public WebIntentPickerModelObserver {
  public:
   WebIntentPickerMock()
       : num_installed_services_(0),
         num_icons_changed_(0),
+        num_extension_icons_changed_(0),
         message_loop_started_(false),
         pending_async_completed_(false) {
   }
 
   virtual void OnModelChanged(WebIntentPickerModel* model) OVERRIDE {
     num_installed_services_ =
         static_cast<int>(model->GetInstalledServiceCount());
   }
 
   virtual void OnFaviconChanged(
       WebIntentPickerModel* model, size_t index) OVERRIDE {
     num_icons_changed_++;
   }
 
+  virtual void OnExtensionIconChanged(
+      WebIntentPickerModel* model, const string16& extension_id) OVERRIDE {
+    num_extension_icons_changed_++;
+  }
+
   virtual void OnInlineDisposition(WebIntentPickerModel* model) OVERRIDE {}
   virtual void Close() OVERRIDE {}
 
   virtual void OnPendingAsyncCompleted() OVERRIDE {
     pending_async_completed_ = true;
 
     if (message_loop_started_)
       MessageLoop::current()->Quit();
   }
 
   void WaitForPendingAsync() {
     if (!pending_async_completed_) {
       message_loop_started_ = true;
       ui_test_utils::RunMessageLoop();
     }
   }
 
   int num_installed_services_;
   int num_icons_changed_;
+  int num_extension_icons_changed_;
   bool message_loop_started_;
   bool pending_async_completed_;
 };
 
 class IntentsDispatcherMock : public content::WebIntentsDispatcher {
  public:
   explicit IntentsDispatcherMock(const webkit_glue::WebIntentData& intent)
       : intent_(intent),
         dispatched_(false) {}
 
@@ skipping 17 matching lines @@
   bool dispatched_;
 };
 
 class WebIntentPickerControllerBrowserTest : public InProcessBrowserTest {
  protected:
   typedef WebIntentPickerModel::Disposition Disposition;
 
   WebIntentPickerControllerBrowserTest() {}
 
   virtual void SetUpOnMainThread() OVERRIDE {
+    // The FakeURLFetcherFactory will return a NULL URLFetcher if a request is

[Greg Billock, 2012/02/23 18:38:34]

I don't understand this. Aren't the only urls you fetch going to be
pre-populated?

[binji, 2012/02/23 19:06:13]

I thought so too, but it turns out some other systems fire off URL fetches in
browser process tests.

[Greg Billock, 2012/02/23 22:15:49]

So where are the requests getting delayed? Does the FakeURLFetcher just eat
requests?

+    // created for a URL it doesn't know and there is no default factory.
+    // Instead, use this dummy factory to infinitely delay the request.
+    default_url_fetcher_factory_.reset(new DummyURLFetcherFactory);
+    fake_url_fetcher_factory_.reset(
+        new FakeURLFetcherFactory(default_url_fetcher_factory_.get()));
+
     web_data_service_ =
         browser()->profile()->GetWebDataService(Profile::EXPLICIT_ACCESS);
     favicon_service_ =
         browser()->profile()->GetFaviconService(Profile::EXPLICIT_ACCESS);
     controller_ = browser()->
         GetSelectedTabContentsWrapper()->web_intent_picker_controller();
 
     controller_->set_picker(&picker_);
     controller_->set_model_observer(&picker_);
+
+    CreateFakeIcon();
   }
 
   void AddWebIntentService(const string16& action, const GURL& service_url) {
     webkit_glue::WebIntentServiceData service;
     service.action = action;
     service.type = kType;
     service.service_url = service_url;
     web_data_service_->AddWebIntentService(service);
   }
 
   void AddCWSExtensionServiceEmpty(const string16& action) {
     GURL cws_query_url = CWSIntentsRegistry::BuildQueryURL(action, kType);
-    fake_url_fetcher_factory_.SetFakeResponse(cws_query_url.spec(),
+    fake_url_fetcher_factory_->SetFakeResponse(cws_query_url.spec(),
         kCWSResponseEmpty, true);
   }
 
   void AddCWSExtensionServiceWithResult(const string16& action) {
     GURL cws_query_url = CWSIntentsRegistry::BuildQueryURL(action, kType);
+    std::string icon_url;
+    std::string escaped_action = net::EscapePath(UTF16ToUTF8(action));
+    base::SStringPrintf(&icon_url, kCWSFakeIconURLFormat,
+        escaped_action.c_str());
+
     std::string response;
     base::SStringPrintf(&response, kCWSResponseResultFormat,
-        UTF16ToUTF8(action).c_str(), UTF16ToUTF8(kType).c_str());
-    fake_url_fetcher_factory_.SetFakeResponse(cws_query_url.spec(), response,
+        UTF16ToUTF8(action).c_str(), UTF16ToUTF8(kType).c_str(),
+        icon_url.c_str());
+    fake_url_fetcher_factory_->SetFakeResponse(cws_query_url.spec(), response,
+        true);
+
+    fake_url_fetcher_factory_->SetFakeResponse(icon_url, icon_response_,
         true);
   }
 
   void OnSendReturnMessage(
     webkit_glue::WebIntentReplyType reply_type) {
     controller_->OnSendReturnMessage(reply_type);
   }
 
   void OnServiceChosen(size_t index, Disposition disposition) {
     controller_->OnServiceChosen(index, disposition);
   }
 
   void OnCancelled() {
     controller_->OnCancelled();
   }
 
+  void CreateFakeIcon() {
+    gfx::Image image(gfx::test::CreateImage());
+    std::vector<unsigned char> image_data;
+    bool result = gfx::PNGEncodedDataFromImage(image, &image_data);
+    DCHECK(result);
+
+    std::copy(image_data.begin(), image_data.end(),
+        std::back_inserter(icon_response_));
+  }
+
   WebIntentPickerMock picker_;
   WebDataService* web_data_service_;
   FaviconService* favicon_service_;
   WebIntentPickerController* controller_;
-  FakeURLFetcherFactory fake_url_fetcher_factory_;
+  scoped_ptr<DummyURLFetcherFactory> default_url_fetcher_factory_;
+  scoped_ptr<FakeURLFetcherFactory> fake_url_fetcher_factory_;
+  std::string icon_response_;
 };
 
 IN_PROC_BROWSER_TEST_F(WebIntentPickerControllerBrowserTest, ChooseService) {
   AddWebIntentService(kAction1, kServiceURL1);
   AddWebIntentService(kAction1, kServiceURL2);
   AddCWSExtensionServiceEmpty(kAction1);
 
   controller_->ShowDialog(browser(), kAction1, kType);
   picker_.WaitForPendingAsync();
   EXPECT_EQ(2, picker_.num_installed_services_);
   EXPECT_EQ(0, picker_.num_icons_changed_);
 
   webkit_glue::WebIntentData intent;
   intent.action = ASCIIToUTF16("a");
   intent.type = ASCIIToUTF16("b");
   IntentsDispatcherMock dispatcher(intent);
   controller_->SetIntentsDispatcher(&dispatcher);
 
   OnServiceChosen(1, WebIntentPickerModel::DISPOSITION_WINDOW);
   ASSERT_EQ(2, browser()->tab_count());
   EXPECT_EQ(GURL(kServiceURL2),
             browser()->GetSelectedWebContents()->GetURL());
 
   EXPECT_TRUE(dispatcher.dispatched_);
 
   OnSendReturnMessage(webkit_glue::WEB_INTENT_REPLY_SUCCESS);
   ASSERT_EQ(1, browser()->tab_count());
 }
 
+IN_PROC_BROWSER_TEST_F(WebIntentPickerControllerBrowserTest,
+                       FetchExtensionIcon) {
+  AddWebIntentService(kAction1, kServiceURL1);
+  AddWebIntentService(kAction1, kServiceURL2);
+  AddCWSExtensionServiceWithResult(kAction1);
+
+  controller_->ShowDialog(browser(), kAction1, kType);
+  picker_.WaitForPendingAsync();
+  EXPECT_EQ(2, picker_.num_installed_services_);
+  EXPECT_EQ(0, picker_.num_icons_changed_);
+  EXPECT_EQ(1, picker_.num_extension_icons_changed_);
+}
+
 IN_PROC_BROWSER_TEST_F(WebIntentPickerControllerBrowserTest, OpenCancelOpen) {
   AddWebIntentService(kAction1, kServiceURL1);
   AddWebIntentService(kAction1, kServiceURL2);
   AddCWSExtensionServiceEmpty(kAction1);
 
   controller_->ShowDialog(browser(), kAction1, kType);
   picker_.WaitForPendingAsync();
   OnCancelled();
 
   controller_->ShowDialog(browser(), kAction1, kType);
@@ skipping 28 matching lines @@
   ASSERT_EQ(3, browser()->tab_count());
   EXPECT_EQ(GURL(kServiceURL1),
             browser()->GetSelectedWebContents()->GetURL());
 
   EXPECT_TRUE(dispatcher.dispatched_);
 
   OnSendReturnMessage(webkit_glue::WEB_INTENT_REPLY_SUCCESS);
   ASSERT_EQ(2, browser()->tab_count());
   EXPECT_EQ(original, browser()->GetSelectedWebContents()->GetURL());
 }