mock_web_bundle_parser_factory.cc 6.6 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189
  1. // Copyright 2022 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. #include "components/web_package/test_support/mock_web_bundle_parser_factory.h"
  5. #include "base/run_loop.h"
  6. #include "base/test/test_future.h"
  7. #include "base/threading/thread_restrictions.h"
  8. #include "components/web_package/test_support/mock_web_bundle_parser.h"
  9. #include "testing/gtest/include/gtest/gtest.h"
  10. namespace web_package {
  11. MockWebBundleParserFactory::MockWebBundleParserFactory() = default;
  12. MockWebBundleParserFactory::~MockWebBundleParserFactory() = default;
  13. void MockWebBundleParserFactory::AddReceiver(
  14. mojo::PendingReceiver<mojom::WebBundleParserFactory> receiver) {
  15. receivers_.Add(this, std::move(receiver));
  16. }
  17. void MockWebBundleParserFactory::WaitUntilParseIntegrityBlockCalled(
  18. base::OnceClosure closure) {
  19. if (parser_)
  20. parser_->WaitUntilParseIntegrityBlockCalled(std::move(closure));
  21. else
  22. wait_parse_integrity_block_callback_ = std::move(closure);
  23. }
  24. void MockWebBundleParserFactory::WaitUntilParseMetadataCalled(
  25. base::OnceCallback<void(int64_t offset)> callback) {
  26. if (parser_)
  27. parser_->WaitUntilParseMetadataCalled(std::move(callback));
  28. else
  29. wait_parse_metadata_callback_ = std::move(callback);
  30. }
  31. void MockWebBundleParserFactory::RunIntegrityBlockCallback(
  32. mojom::BundleIntegrityBlockPtr integrity_block,
  33. web_package::mojom::BundleIntegrityBlockParseErrorPtr error) {
  34. base::RunLoop run_loop;
  35. WaitUntilParseIntegrityBlockCalled(run_loop.QuitClosure());
  36. run_loop.Run();
  37. ASSERT_TRUE(parser_);
  38. parser_->RunIntegrityBlockCallback(std::move(integrity_block),
  39. std::move(error));
  40. }
  41. void MockWebBundleParserFactory::RunMetadataCallback(
  42. int64_t expected_metadata_offset,
  43. mojom::BundleMetadataPtr metadata,
  44. web_package::mojom::BundleMetadataParseErrorPtr error) {
  45. base::test::TestFuture<int64_t> future;
  46. WaitUntilParseMetadataCalled(future.GetCallback());
  47. EXPECT_EQ(expected_metadata_offset, future.Get());
  48. ASSERT_TRUE(parser_);
  49. parser_->RunMetadataCallback(std::move(metadata), std::move(error));
  50. }
  51. void MockWebBundleParserFactory::RunResponseCallback(
  52. mojom::BundleResponseLocationPtr expected_parse_args,
  53. mojom::BundleResponsePtr response,
  54. mojom::BundleResponseParseErrorPtr error) {
  55. ASSERT_TRUE(parser_);
  56. base::test::TestFuture<mojom::BundleResponseLocationPtr> future;
  57. parser_->WaitUntilParseResponseCalled(future.GetCallback());
  58. auto parse_args = future.Take();
  59. EXPECT_EQ(expected_parse_args->offset, parse_args->offset);
  60. EXPECT_EQ(expected_parse_args->length, parse_args->length);
  61. parser_->RunResponseCallback(std::move(response), std::move(error));
  62. }
  63. void MockWebBundleParserFactory::SetIntegrityBlockParseResult(
  64. mojom::BundleIntegrityBlockPtr integrity_block,
  65. mojom::BundleIntegrityBlockParseErrorPtr error) {
  66. integrity_block_parse_result_ =
  67. std::make_pair(std::move(integrity_block), std::move(error));
  68. if (parser_) {
  69. parser_->SetIntegrityBlockParseResult(
  70. integrity_block_parse_result_->first.Clone(),
  71. integrity_block_parse_result_->second.Clone());
  72. }
  73. }
  74. void MockWebBundleParserFactory::SetMetadataParseResult(
  75. mojom::BundleMetadataPtr metadata,
  76. web_package::mojom::BundleMetadataParseErrorPtr error) {
  77. DCHECK(!metadata.is_null());
  78. metadata_parse_result_ =
  79. std::make_pair(std::move(metadata), std::move(error));
  80. if (parser_) {
  81. parser_->SetMetadataParseResult(metadata_parse_result_->first.Clone(),
  82. metadata_parse_result_->second.Clone());
  83. }
  84. }
  85. void MockWebBundleParserFactory::SetResponseParseResult(
  86. mojom::BundleResponsePtr response,
  87. mojom::BundleResponseParseErrorPtr error) {
  88. response_parse_result_ =
  89. std::make_pair(std::move(response), std::move(error));
  90. if (parser_) {
  91. parser_->SetResponseParseResult(response_parse_result_->first.Clone(),
  92. response_parse_result_->second.Clone());
  93. }
  94. }
  95. int MockWebBundleParserFactory::GetParserCreationCount() const {
  96. return parser_creation_count_;
  97. }
  98. void MockWebBundleParserFactory::SimulateParserDisconnect() {
  99. parser_->SimulateDisconnect();
  100. }
  101. void MockWebBundleParserFactory::SimulateParseIntegrityBlockCrash() {
  102. simulate_parse_integrity_block_crash_ = true;
  103. }
  104. void MockWebBundleParserFactory::SimulateParseMetadataCrash() {
  105. simulate_parse_metadata_crash_ = true;
  106. }
  107. void MockWebBundleParserFactory::SimulateParseResponseCrash() {
  108. simulate_parse_response_crash_ = true;
  109. }
  110. void MockWebBundleParserFactory::GetParser(
  111. mojo::PendingReceiver<mojom::WebBundleParser> receiver) {
  112. if (parser_) {
  113. // If a parser existed previously, assume that it has been disconnected, and
  114. // copy its `wait_` callbacks over to the new instance.
  115. parser_ = std::make_unique<MockWebBundleParser>(
  116. std::move(receiver), simulate_parse_integrity_block_crash_,
  117. simulate_parse_metadata_crash_, simulate_parse_response_crash_,
  118. std::move(parser_));
  119. } else {
  120. parser_ = std::make_unique<MockWebBundleParser>(
  121. std::move(receiver), simulate_parse_integrity_block_crash_,
  122. simulate_parse_metadata_crash_, simulate_parse_response_crash_);
  123. }
  124. ++parser_creation_count_;
  125. if (!wait_parse_integrity_block_callback_.is_null()) {
  126. parser_->WaitUntilParseIntegrityBlockCalled(
  127. std::move(wait_parse_integrity_block_callback_));
  128. }
  129. if (!wait_parse_metadata_callback_.is_null()) {
  130. parser_->WaitUntilParseMetadataCalled(
  131. std::move(wait_parse_metadata_callback_));
  132. }
  133. if (integrity_block_parse_result_.has_value()) {
  134. parser_->SetIntegrityBlockParseResult(
  135. integrity_block_parse_result_->first.Clone(),
  136. integrity_block_parse_result_->second.Clone());
  137. }
  138. if (metadata_parse_result_.has_value()) {
  139. parser_->SetMetadataParseResult(metadata_parse_result_->first.Clone(),
  140. metadata_parse_result_->second.Clone());
  141. }
  142. if (response_parse_result_.has_value()) {
  143. parser_->SetResponseParseResult(response_parse_result_->first.Clone(),
  144. response_parse_result_->second.Clone());
  145. }
  146. }
  147. void MockWebBundleParserFactory::GetParserForFile(
  148. mojo::PendingReceiver<mojom::WebBundleParser> receiver,
  149. base::File file) {
  150. {
  151. base::ScopedAllowBlockingForTesting allow_blocking;
  152. file.Close();
  153. }
  154. GetParser(std::move(receiver));
  155. }
  156. void MockWebBundleParserFactory::GetParserForDataSource(
  157. mojo::PendingReceiver<mojom::WebBundleParser> receiver,
  158. mojo::PendingRemote<mojom::BundleDataSource> data_source) {
  159. GetParser(std::move(receiver));
  160. }
  161. } // namespace web_package