Add default intents methods for web data service.

chrome/browser/webdata/web_data_service_unittest.cc

 // Copyright (c) 2011 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 <string>
 #include <vector>
 
 #include "base/basictypes.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/memory/scoped_vector.h"
 #include "base/message_loop.h"
 #include "base/scoped_temp_dir.h"
 #include "base/stl_util.h"
 #include "base/string16.h"
 #include "base/string_util.h"
 #include "base/synchronization/waitable_event.h"
 #include "base/time.h"
 #include "base/utf_string_conversions.h"
 #include "chrome/browser/autofill/autofill_profile.h"
 #include "chrome/browser/autofill/credit_card.h"
+#include "chrome/browser/intents/default_web_intent_service.h"
 #include "chrome/browser/webdata/autofill_change.h"
 #include "chrome/browser/webdata/autofill_entry.h"
 #include "chrome/browser/webdata/web_data_service.h"
 #include "chrome/browser/webdata/web_data_service_test_util.h"
 #include "chrome/browser/webdata/web_intents_table.h"
 #include "chrome/common/chrome_notification_types.h"
 #include "chrome/common/chrome_paths.h"
 #include "chrome/common/guid.h"
 #include "chrome/test/base/thread_observer_helper.h"
 #include "content/public/browser/notification_details.h"
@@ skipping 107 matching lines @@
   string16 name1_;
   string16 name2_;
   string16 value1_;
   string16 value2_;
   int unique_id1_, unique_id2_;
   const TimeDelta test_timeout_;
   scoped_refptr<AutofillDBThreadObserverHelper> observer_helper_;
   WaitableEvent done_event_;
 };
 
-// Simple consumer for WebIntents data. Stores the result data and quits UI
-// message loop when callback is invoked.
+// Simple consumer for WebIntents service data. Stores the result data and
+// quits UI message loop when callback is invoked.
 class WebIntentsConsumer : public WebDataServiceConsumer {
  public:
   virtual void OnWebDataServiceRequestDone(WebDataService::Handle h,
                                            const WDTypedResult* result) {
     services_.clear();
     if (result) {
       DCHECK(result->GetType() == WEB_INTENTS_RESULT);
       services_ = static_cast<
           const WDResult<std::vector<WebIntentServiceData> >*>(result)->
               GetValue();
     }
 
     DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
     MessageLoop::current()->Quit();
   }
 
   // Run the current message loop. OnWebDataServiceRequestDone will invoke
   // MessageLoop::Quit on completion, so this call will finish at that point.
   static void WaitUntilCalled() {
     DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
     MessageLoop::current()->Run();
   }
 
   // Result data from completion callback.
   std::vector<WebIntentServiceData> services_;
 };
 
+// Simple consumer for WebIntents defaults data. Stores the result data and
+// quits UI message loop when callback is invoked.
+class WebIntentsDefaultsConsumer : public WebDataServiceConsumer {

[groby-ooo-7-16, 2012/02/16 23:14:38]

That's a lot of copy/paste - can we just templatize and typedef?

[Greg Billock, 2012/02/17 01:12:37]

This whole file has tons of this parallel structure. If they all used a common
template that'd perhaps be an advantage, but I don't know that picking out these
two will help. In any case, tests tend to be read more directly, and too much
fanciness just makes it harder to figure out what's going on.

[groby-ooo-7-16, 2012/02/17 02:15:01]

At the very least, let's hoist WaitUntilCalled into an anonymous namespace. It
exists at least three times and does nothing class-specific.

On 2012/02/17 01:12:37, Greg Billock wrote:

[Greg Billock, 2012/02/17 17:57:00]

I like it. Done.

On 2012/02/17 02:15:01, groby wrote:

+ public:
+  virtual void OnWebDataServiceRequestDone(WebDataService::Handle h,
+                                           const WDTypedResult* result) {
+    services_.clear();
+    if (result) {
+      DCHECK(result->GetType() == WEB_INTENTS_DEFAULTS_RESULT);
+      services_ = static_cast<
+          const WDResult<std::vector<DefaultWebIntentService> >*>(result)->
+              GetValue();
+    }
+
+    DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+    MessageLoop::current()->Quit();
+  }
+
+  // Run the current message loop. OnWebDataServiceRequestDone will invoke
+  // MessageLoop::Quit on completion, so this call will finish at that point.
+  static void WaitUntilCalled() {
+    DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+    MessageLoop::current()->Run();
+  }
+
+  // Result data from completion callback.
+  std::vector<DefaultWebIntentService> services_;
+};
+
 // Simple consumer for Keywords data. Stores the result data and quits UI
 // message loop when callback is invoked.
 class KeywordsConsumer : public WebDataServiceConsumer {
  public:
   KeywordsConsumer() : load_succeeded(false) {}
 
   virtual void OnWebDataServiceRequestDone(WebDataService::Handle h,
                                            const WDTypedResult* result) {
     if (result) {
       load_succeeded = true;
@@ skipping 530 matching lines @@
   ASSERT_EQ(2U, consumer.services_.size());
 
   if (consumer.services_[0].action != ASCIIToUTF16("edit"))
     std::swap(consumer.services_[0],consumer.services_[1]);
 
   EXPECT_EQ(service, consumer.services_[0]);
   service.action = ASCIIToUTF16("share");
   EXPECT_EQ(service, consumer.services_[1]);
 }
 
+TEST_F(WebDataServiceTest, WebIntentsDefaultsTest) {
+  WebIntentsDefaultsConsumer consumer;
+
+  wds_->GetDefaultWebIntentServicesForAction(ASCIIToUTF16("share"), &consumer);
+  WebIntentsConsumer::WaitUntilCalled();
+  EXPECT_EQ(0U, consumer.services_.size());
+
+  DefaultWebIntentService default_service;
+  default_service.action = ASCIIToUTF16("share");
+  default_service.type = ASCIIToUTF16("type");
+  default_service.user_date = 1;
+  default_service.suppression = 4;
+  default_service.service_url = "service_url";
+  wds_->AddDefaultWebIntentService(default_service);
+
+  default_service.action = ASCIIToUTF16("share2");
+  default_service.service_url = "service_url_2";
+  wds_->AddDefaultWebIntentService(default_service);
+
+  wds_->GetDefaultWebIntentServicesForAction(ASCIIToUTF16("share"), &consumer);
+  WebIntentsDefaultsConsumer::WaitUntilCalled();
+  EXPECT_EQ(1U, consumer.services_.size());

[groby-ooo-7-16, 2012/02/16 23:14:38]

You probably want ASSERT_EQ on the size. If it's 0, you'll get nasty crashes in
the unit tests since they continue past a failed EXPECT. (Here and elsewhere)

[Greg Billock, 2012/02/17 01:12:37]

Done.

+  EXPECT_EQ("service_url", consumer.services_[0].service_url);
+
+  wds_->GetAllDefaultWebIntentServices(&consumer);
+  WebIntentsDefaultsConsumer::WaitUntilCalled();
+  EXPECT_EQ(2U, consumer.services_.size());
+
+  default_service.action = ASCIIToUTF16("share");
+  wds_->RemoveDefaultWebIntentService(default_service);
+
+  wds_->GetDefaultWebIntentServicesForAction(ASCIIToUTF16("share"), &consumer);
+  WebIntentsDefaultsConsumer::WaitUntilCalled();
+  EXPECT_EQ(0U, consumer.services_.size());
+
+  wds_->GetDefaultWebIntentServicesForAction(ASCIIToUTF16("share2"), &consumer);
+  WebIntentsDefaultsConsumer::WaitUntilCalled();
+  EXPECT_EQ(1U, consumer.services_.size());
+  EXPECT_EQ("service_url_2", consumer.services_[0].service_url);
+
+  wds_->GetAllDefaultWebIntentServices(&consumer);
+  WebIntentsDefaultsConsumer::WaitUntilCalled();
+  EXPECT_EQ(1U, consumer.services_.size());
+  EXPECT_EQ("service_url_2", consumer.services_[0].service_url);
+}
+
 TEST_F(WebDataServiceTest, DidDefaultSearchProviderChangeOnNewProfile) {
   KeywordsConsumer consumer;
   wds_->GetKeywords(&consumer);
   KeywordsConsumer::WaitUntilCalled();
   ASSERT_TRUE(consumer.load_succeeded);
   EXPECT_FALSE(consumer.keywords_result.did_default_search_provider_change);
   EXPECT_EQ(NULL, consumer.keywords_result.default_search_provider_backup);
 }