extensions/test/extension_test_message_listener.cc

   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 "extensions/test/extension_test_message_listener.h"
   6
   7 #include "base/strings/string_number_conversions.h"
   8 #include "base/strings/string_util.h"
   9 #include "content/public/browser/notification_service.h"
  10 #include "content/public/browser/notification_source.h"
  11 #include "content/public/test/test_utils.h"
  12 #include "extensions/browser/api/test/test_api.h"
  13 #include "extensions/browser/notification_types.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,
  26                  extensions::NOTIFICATION_EXTENSION_TEST_MESSAGE,
  27                  content::NotificationService::AllSources());
  28 }
  29
  30 ExtensionTestMessageListener::ExtensionTestMessageListener(bool will_reply)
  31     : satisfied_(false),
  32       waiting_(false),
  33       wait_for_any_message_(true),
  34       will_reply_(will_reply),
  35       replied_(false),
  36       failed_(false) {
  37   registrar_.Add(this,
  38                  extensions::NOTIFICATION_EXTENSION_TEST_MESSAGE,
  39                  content::NotificationService::AllSources());
  40 }
  41
  42 ExtensionTestMessageListener::~ExtensionTestMessageListener() {}
  43
  44 bool ExtensionTestMessageListener::WaitUntilSatisfied()  {
  45   if (satisfied_)
  46     return !failed_;
  47   waiting_ = true;
  48   content::RunMessageLoop();
  49   return !failed_;
  50 }
  51
  52 void ExtensionTestMessageListener::Reply(const std::string& message) {
  53   CHECK(satisfied_);
  54   CHECK(!replied_);
  55
  56   replied_ = true;
  57   function_->Reply(message);
  58   function_ = NULL;
  59 }
  60
  61 void ExtensionTestMessageListener::Reply(int message) {
  62   Reply(base::IntToString(message));
  63 }
  64
  65 void ExtensionTestMessageListener::ReplyWithError(const std::string& error) {
  66   CHECK(satisfied_);
  67   CHECK(!replied_);
  68
  69   replied_ = true;
  70   function_->ReplyWithError(error);
  71   function_ = NULL;
  72 }
  73
  74 void ExtensionTestMessageListener::Reset() {
  75   satisfied_ = false;
  76   failed_ = false;
  77   message_.clear();
  78   replied_ = false;
  79 }
  80
  81 void ExtensionTestMessageListener::Observe(
  82     int type,
  83     const content::NotificationSource& source,
  84     const content::NotificationDetails& details) {
  85   DCHECK_EQ(extensions::NOTIFICATION_EXTENSION_TEST_MESSAGE, type);
  86
  87   // Return immediately if we're already satisfied or it's not the right
  88   // extension.
  89   extensions::TestSendMessageFunction* function =
  90       content::Source<extensions::TestSendMessageFunction>(source).ptr();
  91   if (satisfied_ ||
  92       (!extension_id_.empty() && function->extension_id() != extension_id_)) {
  93     return;
  94   }
  95
  96   // We should have an empty message if we're not already satisfied.
  97   CHECK(message_.empty());
  98
  99   const std::string& message = *content::Details<std::string>(details).ptr();
 100   if (message == expected_message_ || wait_for_any_message_ ||
 101       (!failure_message_.empty() && message == failure_message_)) {
 102     message_ = message;
 103     satisfied_ = true;
 104     failed_ = (message_ == failure_message_);
 105
 106     // Reply immediately, or save the function for future use.
 107     function_ = function;
 108     if (!will_reply_)
 109       Reply(std::string());
 110
 111     if (waiting_) {
 112       waiting_ = false;
 113       base::MessageLoopForUI::current()->Quit();
 114     }
 115   }
 116 }