Add a new GetInstance() method for singleton classes, take 2.

media/filters/ffmpeg_glue_unittest.cc

 // Copyright (c) 2010 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 "base/logging.h"
 #include "base/scoped_ptr.h"
 #include "media/base/mock_ffmpeg.h"
 #include "media/base/mock_filters.h"
 #include "media/ffmpeg/ffmpeg_common.h"
 #include "media/filters/ffmpeg_glue.h"
@@ skipping 25 matching lines @@
 
 class FFmpegGlueTest : public ::testing::Test {
  public:
   FFmpegGlueTest() {
   }
 
   virtual void SetUp() {
     MockFFmpeg::set(&mock_ffmpeg_);
 
     // Singleton should initialize FFmpeg.
-    CHECK(FFmpegGlue::get());
+    CHECK(FFmpegGlue::GetInstance());
 
     // Assign our static copy of URLProtocol for the rest of the tests.
     protocol_ = MockFFmpeg::protocol();
     CHECK(protocol_);
   }
 
   virtual void TearDown() {
     MockFFmpeg::set(NULL);
   }
 
   // Helper to open a URLContext pointing to the given mocked protocol.
   // Callers are expected to close the context at the end of their test.
   virtual void OpenContext(MockProtocol* protocol, URLContext* context) {
     // IsStreaming() is called when opening.
     EXPECT_CALL(*protocol, IsStreaming()).WillOnce(Return(true));
 
     // Add the protocol to the glue layer and open a context.
-    std::string key = FFmpegGlue::get()->AddProtocol(protocol);
+    std::string key = FFmpegGlue::GetInstance()->AddProtocol(protocol);
     memset(context, 0, sizeof(*context));
     EXPECT_EQ(0, protocol_->url_open(context, key.c_str(), 0));
-    FFmpegGlue::get()->RemoveProtocol(protocol);
+    FFmpegGlue::GetInstance()->RemoveProtocol(protocol);
   }
 
  protected:
   // Fixture members.
   MockFFmpeg mock_ffmpeg_;
   static URLProtocol* protocol_;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(FFmpegGlueTest);
 };
 
 URLProtocol* FFmpegGlueTest::protocol_ = NULL;
 
 TEST_F(FFmpegGlueTest, InitializeFFmpeg) {
   // Make sure URLProtocol was filled out correctly.
   EXPECT_STREQ("http", protocol_->name);
   EXPECT_TRUE(protocol_->url_close);
   EXPECT_TRUE(protocol_->url_open);
   EXPECT_TRUE(protocol_->url_read);
   EXPECT_TRUE(protocol_->url_seek);
   EXPECT_TRUE(protocol_->url_write);
 }
 
 TEST_F(FFmpegGlueTest, AddRemoveGetProtocol) {
   // Prepare testing data.
-  FFmpegGlue* glue = FFmpegGlue::get();
+  FFmpegGlue* glue = FFmpegGlue::GetInstance();
 
   // Create our protocols and add them to the glue layer.
   scoped_ptr<StrictMock<Destroyable<MockProtocol> > > protocol_a(
       new StrictMock<Destroyable<MockProtocol> >());
   scoped_ptr<StrictMock<Destroyable<MockProtocol> > > protocol_b(
       new StrictMock<Destroyable<MockProtocol> >());
 
   // Make sure the keys are unique.
   std::string key_a = glue->AddProtocol(protocol_a.get());
   std::string key_b = glue->AddProtocol(protocol_b.get());
@@ skipping 33 matching lines @@
   EXPECT_FALSE(protocol_d);
   protocol_a.reset();
   protocol_b.reset();
 
   // Data sources should be deleted by this point.
   mock_ffmpeg_.CheckPoint(0);
 }
 
 TEST_F(FFmpegGlueTest, OpenClose) {
   // Prepare testing data.
-  FFmpegGlue* glue = FFmpegGlue::get();
+  FFmpegGlue* glue = FFmpegGlue::GetInstance();
 
   // Create our protocol and add them to the glue layer.
   scoped_ptr<StrictMock<Destroyable<MockProtocol> > > protocol(
       new StrictMock<Destroyable<MockProtocol> >());
   EXPECT_CALL(*protocol, IsStreaming()).WillOnce(Return(true));
   std::string key = glue->AddProtocol(protocol.get());
 
   // Prepare FFmpeg URLContext structure.
   URLContext context;
   memset(&context, 0, sizeof(context));
@@ skipping 146 matching lines @@
   EXPECT_EQ(16, protocol_->url_seek(&context, 0, AVSEEK_SIZE));
 
   // Destroy the protocol.
   protocol_->url_close(&context);
 }
 
 TEST_F(FFmpegGlueTest, Destroy) {
   // Create our protocol and add them to the glue layer.
   scoped_ptr<StrictMock<Destroyable<MockProtocol> > > protocol(
       new StrictMock<Destroyable<MockProtocol> >());
-  std::string key = FFmpegGlue::get()->AddProtocol(protocol.get());
+  std::string key = FFmpegGlue::GetInstance()->AddProtocol(protocol.get());
 
   // We should expect the protocol to get destroyed when the unit test
   // exits.
   InSequence s;
   EXPECT_CALL(mock_ffmpeg_, CheckPoint(0));
   EXPECT_CALL(*protocol, OnDestroy());
 
   // Remove our own reference, we shouldn't be destroyed yet.
   mock_ffmpeg_.CheckPoint(0);
   protocol.reset();
 
   // ~FFmpegGlue() will be called when this unit test finishes execution.  By
   // leaving something inside FFmpegGlue's map we get to test our cleanup code.
 }
 
 }  // namespace media