Home | History | Annotate | Download | only in extensions 
      1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
      2 // Use of this source code is governed by a BSD-style license that can be
      3 // found in the LICENSE file.
      4 
      5 #include "chrome/browser/extensions/extension_test_message_listener.h"
      6 
      7 #include "base/strings/string_number_conversions.h"
      8 #include "base/strings/string_util.h"
      9 #include "chrome/browser/chrome_notification_types.h"
     10 #include "content/public/browser/notification_service.h"
     11 #include "content/public/browser/notification_source.h"
     12 #include "content/public/test/test_utils.h"
     13 #include "extensions/browser/api/test/test_api.h"
     14 
     15 ExtensionTestMessageListener::ExtensionTestMessageListener(
     16     const std::string& expected_message,
     17     bool will_reply)
     18     : expected_message_(expected_message),
     19       satisfied_(false),
     20       waiting_(false),
     21       wait_for_any_message_(false),
     22       will_reply_(will_reply),
     23       replied_(false),
     24       failed_(false) {
     25   registrar_.Add(this, chrome::NOTIFICATION_EXTENSION_TEST_MESSAGE,
     26                  content::NotificationService::AllSources());
     27 }
     28 
     29 ExtensionTestMessageListener::ExtensionTestMessageListener(bool will_reply)
     30     : satisfied_(false),
     31       waiting_(false),
     32       wait_for_any_message_(true),
     33       will_reply_(will_reply),
     34       replied_(false),
     35       failed_(false) {
     36   registrar_.Add(this,
     37                  chrome::NOTIFICATION_EXTENSION_TEST_MESSAGE,
     38                  content::NotificationService::AllSources());
     39 }
     40 
     41 ExtensionTestMessageListener::~ExtensionTestMessageListener() {}
     42 
     43 bool ExtensionTestMessageListener::WaitUntilSatisfied()  {
     44   if (satisfied_)
     45     return !failed_;
     46   waiting_ = true;
     47   content::RunMessageLoop();
     48   return !failed_;
     49 }
     50 
     51 void ExtensionTestMessageListener::Reply(const std::string& message) {
     52   CHECK(satisfied_);
     53   CHECK(!replied_);
     54 
     55   replied_ = true;
     56   function_->Reply(message);
     57   function_ = NULL;
     58 }
     59 
     60 void ExtensionTestMessageListener::Reply(int message) {
     61   Reply(base::IntToString(message));
     62 }
     63 
     64 void ExtensionTestMessageListener::Reset() {
     65   satisfied_ = false;
     66   failed_ = false;
     67   message_.clear();
     68   replied_ = false;
     69 }
     70 
     71 void ExtensionTestMessageListener::Observe(
     72     int type,
     73     const content::NotificationSource& source,
     74     const content::NotificationDetails& details) {
     75   // Return immediately if we're already satisfied or it's not the right
     76   // extension.
     77   extensions::TestSendMessageFunction* function =
     78       content::Source<extensions::TestSendMessageFunction>(source).ptr();
     79   if (satisfied_ ||
     80       (!extension_id_.empty() && function->extension_id() != extension_id_)) {
     81     return;
     82   }
     83 
     84   // We should have an empty message if we're not already satisfied.
     85   CHECK(message_.empty());
     86 
     87   const std::string& message = *content::Details<std::string>(details).ptr();
     88   if (message == expected_message_ || wait_for_any_message_ ||
     89       (!failure_message_.empty() && message == failure_message_)) {
     90     message_ = message;
     91     satisfied_ = true;
     92     failed_ = (message_ == failure_message_);
     93 
     94     // Reply immediately, or save the function for future use.
     95     function_ = function;
     96     if (!will_reply_)
     97       Reply(std::string());
     98 
     99     if (waiting_) {
    100       waiting_ = false;
    101       base::MessageLoopForUI::current()->Quit();
    102     }
    103   }
    104 }
    105