content/browser/devtools/devtools_http_handler_unittest.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 "base/message_loop/message_loop.h"
   6 #include "base/run_loop.h"
   7 #include "content/browser/browser_thread_impl.h"
   8 #include "content/public/browser/devtools_http_handler.h"
   9 #include "content/public/browser/devtools_http_handler_delegate.h"
  10 #include "content/public/browser/devtools_target.h"
  11 #include "net/socket/stream_listen_socket.h"
  12 #include "testing/gtest/include/gtest/gtest.h"
  13
  14 namespace content {
  15 namespace {
  16
  17 using net::StreamListenSocket;
  18
  19 class DummyListenSocket : public StreamListenSocket,
  20                           public StreamListenSocket::Delegate {
  21  public:
  22   DummyListenSocket()
  23       : StreamListenSocket(0, this) {}
  24
  25   // StreamListenSocket::Delegate "implementation"
  26   virtual void DidAccept(StreamListenSocket* server,
  27                          scoped_ptr<StreamListenSocket> connection) OVERRIDE {}
  28   virtual void DidRead(StreamListenSocket* connection,
  29                        const char* data,
  30                        int len) OVERRIDE {}
  31   virtual void DidClose(StreamListenSocket* sock) OVERRIDE {}
  32  protected:
  33   virtual ~DummyListenSocket() {}
  34   virtual void Accept() OVERRIDE {}
  35 };
  36
  37 class DummyListenSocketFactory : public net::StreamListenSocketFactory {
  38  public:
  39   DummyListenSocketFactory(
  40       base::Closure quit_closure_1, base::Closure quit_closure_2)
  41       : quit_closure_1_(quit_closure_1), quit_closure_2_(quit_closure_2) {}
  42   virtual ~DummyListenSocketFactory() {
  43     BrowserThread::PostTask(
  44         BrowserThread::UI, FROM_HERE, quit_closure_2_);
  45   }
  46
  47   virtual scoped_ptr<StreamListenSocket> CreateAndListen(
  48       StreamListenSocket::Delegate* delegate) const OVERRIDE {
  49     BrowserThread::PostTask(
  50         BrowserThread::UI, FROM_HERE, quit_closure_1_);
  51     return scoped_ptr<net::StreamListenSocket>(new DummyListenSocket());
  52   }
  53  private:
  54   base::Closure quit_closure_1_;
  55   base::Closure quit_closure_2_;
  56 };
  57
  58 class DummyDelegate : public DevToolsHttpHandlerDelegate {
  59  public:
  60   virtual std::string GetDiscoveryPageHTML() OVERRIDE { return std::string(); }
  61   virtual bool BundlesFrontendResources() OVERRIDE { return true; }
  62   virtual base::FilePath GetDebugFrontendDir() OVERRIDE {
  63     return base::FilePath();
  64   }
  65   virtual std::string GetPageThumbnailData(const GURL& url) OVERRIDE {
  66     return std::string();
  67   }
  68   virtual scoped_ptr<DevToolsTarget> CreateNewTarget(const GURL& url) OVERRIDE {
  69     return scoped_ptr<DevToolsTarget>();
  70   }
  71   virtual void EnumerateTargets(TargetCallback callback) OVERRIDE {
  72     callback.Run(TargetList());
  73   }
  74   virtual scoped_ptr<net::StreamListenSocket> CreateSocketForTethering(
  75     net::StreamListenSocket::Delegate* delegate,
  76     std::string* name) OVERRIDE {
  77     return scoped_ptr<net::StreamListenSocket>();
  78   }
  79 };
  80
  81 }
  82
  83 class DevToolsHttpHandlerTest : public testing::Test {
  84  public:
  85   DevToolsHttpHandlerTest()
  86       : ui_thread_(BrowserThread::UI, &message_loop_) {
  87   }
  88  protected:
  89   virtual void SetUp() {
  90     file_thread_.reset(new BrowserThreadImpl(BrowserThread::FILE));
  91     file_thread_->Start();
  92   }
  93   virtual void TearDown() {
  94     file_thread_->Stop();
  95   }
  96  private:
  97   base::MessageLoopForIO message_loop_;
  98   BrowserThreadImpl ui_thread_;
  99   scoped_ptr<BrowserThreadImpl> file_thread_;
 100 };
 101
 102 TEST_F(DevToolsHttpHandlerTest, TestStartStop) {
 103   base::RunLoop run_loop, run_loop_2;
 104   content::DevToolsHttpHandler* devtools_http_handler_ =
 105       content::DevToolsHttpHandler::Start(
 106           new DummyListenSocketFactory(run_loop.QuitClosure(),
 107                                        run_loop_2.QuitClosure()),
 108           std::string(),
 109           new DummyDelegate());
 110   // Our dummy socket factory will post a quit message once the server will
 111   // become ready.
 112   run_loop.Run();
 113   devtools_http_handler_->Stop();
 114   // Make sure the handler actually stops.
 115   run_loop_2.Run();
 116 }
 117
 118 }  // namespace content