extensions/browser/api/test/test_api.cc

   1 // Copyright 2014 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/browser/api/test/test_api.h"
   6
   7 #include <string>
   8
   9 #include "base/command_line.h"
  10 #include "base/memory/singleton.h"
  11 #include "chrome/browser/chrome_notification_types.h"
  12 #include "content/public/browser/notification_service.h"
  13 #include "content/public/common/content_switches.h"
  14 #include "extensions/browser/extension_function_dispatcher.h"
  15 #include "extensions/browser/extension_system.h"
  16 #include "extensions/browser/quota_service.h"
  17 #include "extensions/common/api/test.h"
  18
  19 namespace {
  20
  21 // If you see this error in your test, you need to set the config state
  22 // to be returned by chrome.test.getConfig().  Do this by calling
  23 // TestGetConfigFunction::set_test_config_state(Value* state)
  24 // in test set up.
  25 const char kNoTestConfigDataError[] = "Test configuration was not set.";
  26
  27 const char kNotTestProcessError[] =
  28     "The chrome.test namespace is only available in tests.";
  29
  30 }  // namespace
  31
  32 namespace extensions {
  33
  34 namespace Log = core_api::test::Log;
  35 namespace NotifyFail = core_api::test::NotifyFail;
  36 namespace PassMessage = core_api::test::PassMessage;
  37 namespace WaitForRoundTrip = core_api::test::WaitForRoundTrip;
  38
  39 TestExtensionFunction::~TestExtensionFunction() {}
  40
  41 bool TestExtensionFunction::RunSync() {
  42   if (!CommandLine::ForCurrentProcess()->HasSwitch(switches::kTestType)) {
  43     error_ = kNotTestProcessError;
  44     return false;
  45   }
  46   return RunSafe();
  47 }
  48
  49 TestNotifyPassFunction::~TestNotifyPassFunction() {}
  50
  51 bool TestNotifyPassFunction::RunSafe() {
  52   content::NotificationService::current()->Notify(
  53       chrome::NOTIFICATION_EXTENSION_TEST_PASSED,
  54       content::Source<content::BrowserContext>(dispatcher()->browser_context()),
  55       content::NotificationService::NoDetails());
  56   return true;
  57 }
  58
  59 TestNotifyFailFunction::~TestNotifyFailFunction() {}
  60
  61 bool TestNotifyFailFunction::RunSafe() {
  62   scoped_ptr<NotifyFail::Params> params(NotifyFail::Params::Create(*args_));
  63   EXTENSION_FUNCTION_VALIDATE(params.get());
  64   content::NotificationService::current()->Notify(
  65       chrome::NOTIFICATION_EXTENSION_TEST_FAILED,
  66       content::Source<content::BrowserContext>(dispatcher()->browser_context()),
  67       content::Details<std::string>(&params->message));
  68   return true;
  69 }
  70
  71 TestLogFunction::~TestLogFunction() {}
  72
  73 bool TestLogFunction::RunSafe() {
  74   scoped_ptr<Log::Params> params(Log::Params::Create(*args_));
  75   EXTENSION_FUNCTION_VALIDATE(params.get());
  76   VLOG(1) << params->message;
  77   return true;
  78 }
  79
  80 TestResetQuotaFunction::~TestResetQuotaFunction() {}
  81
  82 bool TestResetQuotaFunction::RunSafe() {
  83   QuotaService* quota =
  84       ExtensionSystem::Get(browser_context())->quota_service();
  85   quota->Purge();
  86   quota->violation_errors_.clear();
  87   return true;
  88 }
  89
  90 bool TestSendMessageFunction::RunAsync() {
  91   scoped_ptr<PassMessage::Params> params(PassMessage::Params::Create(*args_));
  92   EXTENSION_FUNCTION_VALIDATE(params.get());
  93   content::NotificationService::current()->Notify(
  94       chrome::NOTIFICATION_EXTENSION_TEST_MESSAGE,
  95       content::Source<TestSendMessageFunction>(this),
  96       content::Details<std::string>(&params->message));
  97   return true;
  98 }
  99
 100 TestSendMessageFunction::~TestSendMessageFunction() {}
 101
 102 void TestSendMessageFunction::Reply(const std::string& message) {
 103   SetResult(new base::StringValue(message));
 104   SendResponse(true);
 105 }
 106
 107 // static
 108 void TestGetConfigFunction::set_test_config_state(
 109     base::DictionaryValue* value) {
 110   TestConfigState* test_config_state = TestConfigState::GetInstance();
 111   test_config_state->set_config_state(value);
 112 }
 113
 114 TestGetConfigFunction::TestConfigState::TestConfigState()
 115     : config_state_(NULL) {}
 116
 117 // static
 118 TestGetConfigFunction::TestConfigState*
 119 TestGetConfigFunction::TestConfigState::GetInstance() {
 120   return Singleton<TestConfigState>::get();
 121 }
 122
 123 TestGetConfigFunction::~TestGetConfigFunction() {}
 124
 125 bool TestGetConfigFunction::RunSafe() {
 126   TestConfigState* test_config_state = TestConfigState::GetInstance();
 127
 128   if (!test_config_state->config_state()) {
 129     error_ = kNoTestConfigDataError;
 130     return false;
 131   }
 132
 133   SetResult(test_config_state->config_state()->DeepCopy());
 134   return true;
 135 }
 136
 137 TestWaitForRoundTripFunction::~TestWaitForRoundTripFunction() {}
 138
 139 bool TestWaitForRoundTripFunction::RunSafe() {
 140   scoped_ptr<WaitForRoundTrip::Params> params(
 141       WaitForRoundTrip::Params::Create(*args_));
 142   SetResult(new base::StringValue(params->message));
 143   return true;
 144 }
 145
 146 }  // namespace extensions