| // Copyright 2021 The Cobalt Authors. All Rights Reserved. | |
| // | |
| // Licensed under the Apache License, Version 2.0 (the "License"); | |
| // you may not use this file except in compliance with the License. | |
| // You may obtain a copy of the License at | |
| // | |
| // http://www.apache.org/licenses/LICENSE-2.0 | |
| // | |
| // Unless required by applicable law or agreed to in writing, software | |
| // distributed under the License is distributed on an "AS IS" BASIS, | |
| // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. | |
| // See the License for the specific language governing permissions and | |
| // limitations under the License. | |
| #ifndef COBALT_LOADER_IMAGE_IMAGE_DECODER_MOCK_H_ | |
| #define COBALT_LOADER_IMAGE_IMAGE_DECODER_MOCK_H_ | |
| #include <memory> | |
| #include <string> | |
| #include "cobalt/loader/image/image_decoder.h" | |
| #include "cobalt/render_tree/resource_provider_stub.h" | |
| #include "testing/gmock/include/gmock/gmock.h" | |
| #include "testing/gtest/include/gtest/gtest.h" | |
| namespace cobalt { | |
| namespace loader { | |
| namespace image { | |
| struct MockImageDecoderCallback { | |
| void SuccessCallback(const scoped_refptr<Image>& value) { image = value; } | |
| MOCK_METHOD1(LoadCompleteCallback, | |
| void(const base::Optional<std::string>& message)); | |
| scoped_refptr<Image> image; | |
| }; | |
| class MockImageDecoder : public Decoder { | |
| public: | |
| MockImageDecoder(); | |
| explicit MockImageDecoder(render_tree::ResourceProvider* resource_provider); | |
| ~MockImageDecoder() override {} | |
| LoadResponseType OnResponseStarted( | |
| Fetcher* fetcher, | |
| const scoped_refptr<net::HttpResponseHeaders>& headers) override; | |
| void DecodeChunk(const char* data, size_t size) override; | |
| void Finish() override; | |
| bool Suspend() override; | |
| void Resume(render_tree::ResourceProvider* resource_provider) override; | |
| scoped_refptr<Image> image(); | |
| void ExpectCallWithError(const base::Optional<std::string>& error); | |
| protected: | |
| std::unique_ptr<render_tree::ResourceProviderStub> resource_provider_stub_; | |
| render_tree::ResourceProvider* resource_provider_; | |
| base::NullDebuggerHooks debugger_hooks_; | |
| ::testing::StrictMock<MockImageDecoderCallback> image_decoder_callback_; | |
| std::unique_ptr<Decoder> image_decoder_; | |
| }; | |
| MockImageDecoder::MockImageDecoder() | |
| : resource_provider_stub_(new render_tree::ResourceProviderStub()), | |
| resource_provider_(resource_provider_stub_.get()) { | |
| image_decoder_.reset(new ImageDecoder( | |
| resource_provider_, debugger_hooks_, | |
| base::Bind(&MockImageDecoderCallback::SuccessCallback, | |
| base::Unretained(&image_decoder_callback_)), | |
| base::Bind(&MockImageDecoderCallback::LoadCompleteCallback, | |
| base::Unretained(&image_decoder_callback_)))); | |
| } | |
| MockImageDecoder::MockImageDecoder( | |
| render_tree::ResourceProvider* resource_provider) | |
| : resource_provider_(resource_provider) { | |
| image_decoder_.reset(new ImageDecoder( | |
| resource_provider_, debugger_hooks_, | |
| base::Bind(&MockImageDecoderCallback::SuccessCallback, | |
| base::Unretained(&image_decoder_callback_)), | |
| base::Bind(&MockImageDecoderCallback::LoadCompleteCallback, | |
| base::Unretained(&image_decoder_callback_)))); | |
| } | |
| LoadResponseType MockImageDecoder::OnResponseStarted( | |
| Fetcher* fetcher, const scoped_refptr<net::HttpResponseHeaders>& headers) { | |
| return image_decoder_->OnResponseStarted(fetcher, headers); | |
| } | |
| void MockImageDecoder::DecodeChunk(const char* data, size_t size) { | |
| image_decoder_->DecodeChunk(data, size); | |
| } | |
| void MockImageDecoder::Finish() { image_decoder_->Finish(); } | |
| bool MockImageDecoder::Suspend() { return image_decoder_->Suspend(); } | |
| void MockImageDecoder::Resume( | |
| render_tree::ResourceProvider* resource_provider) { | |
| image_decoder_->Resume(resource_provider); | |
| } | |
| scoped_refptr<Image> MockImageDecoder::image() { | |
| return image_decoder_callback_.image; | |
| } | |
| void MockImageDecoder::ExpectCallWithError( | |
| const base::Optional<std::string>& error) { | |
| EXPECT_CALL(image_decoder_callback_, LoadCompleteCallback(error)); | |
| } | |
| } // namespace image | |
| } // namespace loader | |
| }; // namespace cobalt | |
| #endif // COBALT_LOADER_IMAGE_IMAGE_DECODER_MOCK_H_ |