content/browser/speech/google_streaming_remote_engine_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 <queue>
   6
   7 #include "base/memory/scoped_ptr.h"
   8 #include "base/message_loop.h"
   9 #include "base/strings/utf_string_conversions.h"
  10 #include "content/browser/speech/audio_buffer.h"
  11 #include "content/browser/speech/google_streaming_remote_engine.h"
  12 #include "content/browser/speech/proto/google_streaming_api.pb.h"
  13 #include "content/public/common/speech_recognition_error.h"
  14 #include "content/public/common/speech_recognition_result.h"
  15 #include "net/url_request/test_url_fetcher_factory.h"
  16 #include "net/url_request/url_request_context_getter.h"
  17 #include "net/url_request/url_request_status.h"
  18 #include "testing/gtest/include/gtest/gtest.h"
  19
  20 using net::URLRequestStatus;
  21 using net::TestURLFetcher;
  22 using net::TestURLFetcherFactory;
  23
  24 namespace content {
  25
  26 // Note: the terms upstream and downstream are from the point-of-view of the
  27 // client (engine_under_test_).
  28
  29 class GoogleStreamingRemoteEngineTest : public SpeechRecognitionEngineDelegate,
  30                                         public testing::Test {
  31  public:
  32   GoogleStreamingRemoteEngineTest()
  33       : last_number_of_upstream_chunks_seen_(0U),
  34         error_(SPEECH_RECOGNITION_ERROR_NONE) { }
  35
  36   // Creates a speech recognition request and invokes its URL fetcher delegate
  37   // with the given test data.
  38   void CreateAndTestRequest(bool success, const std::string& http_response);
  39
  40   // SpeechRecognitionRequestDelegate methods.
  41   virtual void OnSpeechRecognitionEngineResults(
  42       const SpeechRecognitionResults& results) OVERRIDE {
  43     results_.push(results);
  44   }
  45   virtual void OnSpeechRecognitionEngineError(
  46       const SpeechRecognitionError& error) OVERRIDE {
  47     error_ = error.code;
  48   }
  49
  50   // testing::Test methods.
  51   virtual void SetUp() OVERRIDE;
  52   virtual void TearDown() OVERRIDE;
  53
  54  protected:
  55   enum DownstreamError {
  56     DOWNSTREAM_ERROR_NONE,
  57     DOWNSTREAM_ERROR_HTTP500,
  58     DOWNSTREAM_ERROR_NETWORK,
  59     DOWNSTREAM_ERROR_WEBSERVICE_NO_MATCH
  60   };
  61   static bool ResultsAreEqual(const SpeechRecognitionResults& a,
  62                               const SpeechRecognitionResults& b);
  63   static std::string SerializeProtobufResponse(
  64       const proto::SpeechRecognitionEvent& msg);
  65   static std::string ToBigEndian32(uint32 value);
  66
  67   TestURLFetcher* GetUpstreamFetcher();
  68   TestURLFetcher* GetDownstreamFetcher();
  69   void StartMockRecognition();
  70   void EndMockRecognition();
  71   void InjectDummyAudioChunk();
  72   size_t UpstreamChunksUploadedFromLastCall();
  73   void ProvideMockProtoResultDownstream(
  74       const proto::SpeechRecognitionEvent& result);
  75   void ProvideMockResultDownstream(const SpeechRecognitionResult& result);
  76   void ExpectResultsReceived(const SpeechRecognitionResults& result);
  77   void CloseMockDownstream(DownstreamError error);
  78
  79   scoped_ptr<GoogleStreamingRemoteEngine> engine_under_test_;
  80   TestURLFetcherFactory url_fetcher_factory_;
  81   size_t last_number_of_upstream_chunks_seen_;
  82   base::MessageLoop message_loop_;
  83   std::string response_buffer_;
  84   SpeechRecognitionErrorCode error_;
  85   std::queue<SpeechRecognitionResults> results_;
  86 };
  87
  88 TEST_F(GoogleStreamingRemoteEngineTest, SingleDefinitiveResult) {
  89   StartMockRecognition();
  90   ASSERT_TRUE(GetUpstreamFetcher());
  91   ASSERT_EQ(0U, UpstreamChunksUploadedFromLastCall());
  92
  93   // Inject some dummy audio chunks and check a corresponding chunked upload
  94   // is performed every time on the server.
  95   for (int i = 0; i < 3; ++i) {
  96     InjectDummyAudioChunk();
  97     ASSERT_EQ(1U, UpstreamChunksUploadedFromLastCall());
  98   }
  99
 100   // Ensure that a final (empty) audio chunk is uploaded on chunks end.
 101   engine_under_test_->AudioChunksEnded();
 102   ASSERT_EQ(1U, UpstreamChunksUploadedFromLastCall());
 103   ASSERT_TRUE(engine_under_test_->IsRecognitionPending());
 104
 105   // Simulate a protobuf message streamed from the server containing a single
 106   // result with two hypotheses.
 107   SpeechRecognitionResults results;
 108   results.push_back(SpeechRecognitionResult());
 109   SpeechRecognitionResult& result = results.back();
 110   result.is_provisional = false;
 111   result.hypotheses.push_back(
 112       SpeechRecognitionHypothesis(UTF8ToUTF16("hypothesis 1"), 0.1F));
 113   result.hypotheses.push_back(
 114       SpeechRecognitionHypothesis(UTF8ToUTF16("hypothesis 2"), 0.2F));
 115
 116   ProvideMockResultDownstream(result);
 117   ExpectResultsReceived(results);
 118   ASSERT_TRUE(engine_under_test_->IsRecognitionPending());
 119
 120   // Ensure everything is closed cleanly after the downstream is closed.
 121   CloseMockDownstream(DOWNSTREAM_ERROR_NONE);
 122   ASSERT_FALSE(engine_under_test_->IsRecognitionPending());
 123   EndMockRecognition();
 124   ASSERT_EQ(SPEECH_RECOGNITION_ERROR_NONE, error_);
 125   ASSERT_EQ(0U, results_.size());
 126 }
 127
 128 TEST_F(GoogleStreamingRemoteEngineTest, SeveralStreamingResults) {
 129   StartMockRecognition();
 130   ASSERT_TRUE(GetUpstreamFetcher());
 131   ASSERT_EQ(0U, UpstreamChunksUploadedFromLastCall());
 132
 133   for (int i = 0; i < 4; ++i) {
 134     InjectDummyAudioChunk();
 135     ASSERT_EQ(1U, UpstreamChunksUploadedFromLastCall());
 136
 137     SpeechRecognitionResults results;
 138     results.push_back(SpeechRecognitionResult());
 139     SpeechRecognitionResult& result = results.back();
 140     result.is_provisional = (i % 2 == 0);  // Alternate result types.
 141     float confidence = result.is_provisional ? 0.0F : (i * 0.1F);
 142     result.hypotheses.push_back(
 143         SpeechRecognitionHypothesis(UTF8ToUTF16("hypothesis"), confidence));
 144
 145     ProvideMockResultDownstream(result);
 146     ExpectResultsReceived(results);
 147     ASSERT_TRUE(engine_under_test_->IsRecognitionPending());
 148   }
 149
 150   // Ensure that a final (empty) audio chunk is uploaded on chunks end.
 151   engine_under_test_->AudioChunksEnded();
 152   ASSERT_EQ(1U, UpstreamChunksUploadedFromLastCall());
 153   ASSERT_TRUE(engine_under_test_->IsRecognitionPending());
 154
 155   // Simulate a final definitive result.
 156   SpeechRecognitionResults results;
 157   results.push_back(SpeechRecognitionResult());
 158   SpeechRecognitionResult& result = results.back();
 159   result.is_provisional = false;
 160   result.hypotheses.push_back(
 161       SpeechRecognitionHypothesis(UTF8ToUTF16("The final result"), 1.0F));
 162   ProvideMockResultDownstream(result);
 163   ExpectResultsReceived(results);
 164   ASSERT_TRUE(engine_under_test_->IsRecognitionPending());
 165
 166   // Ensure everything is closed cleanly after the downstream is closed.
 167   CloseMockDownstream(DOWNSTREAM_ERROR_NONE);
 168   ASSERT_FALSE(engine_under_test_->IsRecognitionPending());
 169   EndMockRecognition();
 170   ASSERT_EQ(SPEECH_RECOGNITION_ERROR_NONE, error_);
 171   ASSERT_EQ(0U, results_.size());
 172 }
 173
 174 TEST_F(GoogleStreamingRemoteEngineTest, NoFinalResultAfterAudioChunksEnded) {
 175   StartMockRecognition();
 176   ASSERT_TRUE(GetUpstreamFetcher());
 177   ASSERT_EQ(0U, UpstreamChunksUploadedFromLastCall());
 178
 179   // Simulate one pushed audio chunk.
 180   InjectDummyAudioChunk();
 181   ASSERT_EQ(1U, UpstreamChunksUploadedFromLastCall());
 182
 183   // Simulate the corresponding definitive result.
 184   SpeechRecognitionResults results;
 185   results.push_back(SpeechRecognitionResult());
 186   SpeechRecognitionResult& result = results.back();
 187   result.hypotheses.push_back(
 188       SpeechRecognitionHypothesis(UTF8ToUTF16("hypothesis"), 1.0F));
 189   ProvideMockResultDownstream(result);
 190   ExpectResultsReceived(results);
 191   ASSERT_TRUE(engine_under_test_->IsRecognitionPending());
 192
 193   // Simulate a silent downstream closure after |AudioChunksEnded|.
 194   engine_under_test_->AudioChunksEnded();
 195   ASSERT_EQ(1U, UpstreamChunksUploadedFromLastCall());
 196   ASSERT_TRUE(engine_under_test_->IsRecognitionPending());
 197   CloseMockDownstream(DOWNSTREAM_ERROR_NONE);
 198
 199   // Expect an empty result, aimed at notifying recognition ended with no
 200   // actual results nor errors.
 201   SpeechRecognitionResults empty_results;
 202   ExpectResultsReceived(empty_results);
 203
 204   // Ensure everything is closed cleanly after the downstream is closed.
 205   ASSERT_FALSE(engine_under_test_->IsRecognitionPending());
 206   EndMockRecognition();
 207   ASSERT_EQ(SPEECH_RECOGNITION_ERROR_NONE, error_);
 208   ASSERT_EQ(0U, results_.size());
 209 }
 210
 211 TEST_F(GoogleStreamingRemoteEngineTest, NoMatchError) {
 212   StartMockRecognition();
 213   ASSERT_TRUE(GetUpstreamFetcher());
 214   ASSERT_EQ(0U, UpstreamChunksUploadedFromLastCall());
 215
 216   for (int i = 0; i < 3; ++i)
 217     InjectDummyAudioChunk();
 218   engine_under_test_->AudioChunksEnded();
 219   ASSERT_EQ(4U, UpstreamChunksUploadedFromLastCall());
 220   ASSERT_TRUE(engine_under_test_->IsRecognitionPending());
 221
 222   // Simulate only a provisional result.
 223   SpeechRecognitionResults results;
 224   results.push_back(SpeechRecognitionResult());
 225   SpeechRecognitionResult& result = results.back();
 226   result.is_provisional = true;
 227   result.hypotheses.push_back(
 228       SpeechRecognitionHypothesis(UTF8ToUTF16("The final result"), 0.0F));
 229   ProvideMockResultDownstream(result);
 230   ExpectResultsReceived(results);
 231   ASSERT_TRUE(engine_under_test_->IsRecognitionPending());
 232
 233   CloseMockDownstream(DOWNSTREAM_ERROR_WEBSERVICE_NO_MATCH);
 234
 235   // Expect an empty result.
 236   ASSERT_FALSE(engine_under_test_->IsRecognitionPending());
 237   EndMockRecognition();
 238   SpeechRecognitionResults empty_result;
 239   ExpectResultsReceived(empty_result);
 240 }
 241
 242 TEST_F(GoogleStreamingRemoteEngineTest, HTTPError) {
 243   StartMockRecognition();
 244   ASSERT_TRUE(GetUpstreamFetcher());
 245   ASSERT_EQ(0U, UpstreamChunksUploadedFromLastCall());
 246
 247   InjectDummyAudioChunk();
 248   ASSERT_EQ(1U, UpstreamChunksUploadedFromLastCall());
 249
 250   // Close the downstream with a HTTP 500 error.
 251   CloseMockDownstream(DOWNSTREAM_ERROR_HTTP500);
 252
 253   // Expect a SPEECH_RECOGNITION_ERROR_NETWORK error to be raised.
 254   ASSERT_FALSE(engine_under_test_->IsRecognitionPending());
 255   EndMockRecognition();
 256   ASSERT_EQ(SPEECH_RECOGNITION_ERROR_NETWORK, error_);
 257   ASSERT_EQ(0U, results_.size());
 258 }
 259
 260 TEST_F(GoogleStreamingRemoteEngineTest, NetworkError) {
 261   StartMockRecognition();
 262   ASSERT_TRUE(GetUpstreamFetcher());
 263   ASSERT_EQ(0U, UpstreamChunksUploadedFromLastCall());
 264
 265   InjectDummyAudioChunk();
 266   ASSERT_EQ(1U, UpstreamChunksUploadedFromLastCall());
 267
 268   // Close the downstream fetcher simulating a network failure.
 269   CloseMockDownstream(DOWNSTREAM_ERROR_NETWORK);
 270
 271   // Expect a SPEECH_RECOGNITION_ERROR_NETWORK error to be raised.
 272   ASSERT_FALSE(engine_under_test_->IsRecognitionPending());
 273   EndMockRecognition();
 274   ASSERT_EQ(SPEECH_RECOGNITION_ERROR_NETWORK, error_);
 275   ASSERT_EQ(0U, results_.size());
 276 }
 277
 278 TEST_F(GoogleStreamingRemoteEngineTest, Stability) {
 279   StartMockRecognition();
 280   ASSERT_TRUE(GetUpstreamFetcher());
 281   ASSERT_EQ(0U, UpstreamChunksUploadedFromLastCall());
 282
 283   // Upload a dummy audio chunk.
 284   InjectDummyAudioChunk();
 285   ASSERT_EQ(1U, UpstreamChunksUploadedFromLastCall());
 286   engine_under_test_->AudioChunksEnded();
 287
 288   // Simulate a protobuf message with an intermediate result without confidence,
 289   // but with stability.
 290   proto::SpeechRecognitionEvent proto_event;
 291   proto_event.set_status(proto::SpeechRecognitionEvent::STATUS_SUCCESS);
 292   proto::SpeechRecognitionResult* proto_result = proto_event.add_result();
 293   proto_result->set_stability(0.5);
 294   proto::SpeechRecognitionAlternative *proto_alternative =
 295       proto_result->add_alternative();
 296   proto_alternative->set_transcript("foo");
 297   ProvideMockProtoResultDownstream(proto_event);
 298
 299   // Set up expectations.
 300   SpeechRecognitionResults results;
 301   results.push_back(SpeechRecognitionResult());
 302   SpeechRecognitionResult& result = results.back();
 303   result.is_provisional = true;
 304   result.hypotheses.push_back(
 305       SpeechRecognitionHypothesis(UTF8ToUTF16("foo"), 0.5));
 306
 307   // Check that the protobuf generated the expected result.
 308   ExpectResultsReceived(results);
 309
 310   // Since it was a provisional result, recognition is still pending.
 311   ASSERT_TRUE(engine_under_test_->IsRecognitionPending());
 312
 313   // Shut down.
 314   CloseMockDownstream(DOWNSTREAM_ERROR_NONE);
 315   ASSERT_FALSE(engine_under_test_->IsRecognitionPending());
 316   EndMockRecognition();
 317
 318   // Since there was no final result, we get an empty "no match" result.
 319   SpeechRecognitionResults empty_result;
 320   ExpectResultsReceived(empty_result);
 321   ASSERT_EQ(SPEECH_RECOGNITION_ERROR_NONE, error_);
 322   ASSERT_EQ(0U, results_.size());
 323 }
 324
 325 void GoogleStreamingRemoteEngineTest::SetUp() {
 326   engine_under_test_.reset(
 327       new  GoogleStreamingRemoteEngine(NULL /*URLRequestContextGetter*/));
 328   engine_under_test_->set_delegate(this);
 329 }
 330
 331 void GoogleStreamingRemoteEngineTest::TearDown() {
 332   engine_under_test_.reset();
 333 }
 334
 335 TestURLFetcher* GoogleStreamingRemoteEngineTest::GetUpstreamFetcher() {
 336   return url_fetcher_factory_.GetFetcherByID(
 337         GoogleStreamingRemoteEngine::kUpstreamUrlFetcherIdForTests);
 338 }
 339
 340 TestURLFetcher* GoogleStreamingRemoteEngineTest::GetDownstreamFetcher() {
 341   return url_fetcher_factory_.GetFetcherByID(
 342         GoogleStreamingRemoteEngine::kDownstreamUrlFetcherIdForTests);
 343 }
 344
 345 // Starts recognition on the engine, ensuring that both stream fetchers are
 346 // created.
 347 void GoogleStreamingRemoteEngineTest::StartMockRecognition() {
 348   DCHECK(engine_under_test_.get());
 349
 350   ASSERT_FALSE(engine_under_test_->IsRecognitionPending());
 351
 352   engine_under_test_->StartRecognition();
 353   ASSERT_TRUE(engine_under_test_->IsRecognitionPending());
 354
 355   TestURLFetcher* upstream_fetcher = GetUpstreamFetcher();
 356   ASSERT_TRUE(upstream_fetcher);
 357   upstream_fetcher->set_url(upstream_fetcher->GetOriginalURL());
 358
 359   TestURLFetcher* downstream_fetcher = GetDownstreamFetcher();
 360   ASSERT_TRUE(downstream_fetcher);
 361   downstream_fetcher->set_url(downstream_fetcher->GetOriginalURL());
 362 }
 363
 364 void GoogleStreamingRemoteEngineTest::EndMockRecognition() {
 365   DCHECK(engine_under_test_.get());
 366   engine_under_test_->EndRecognition();
 367   ASSERT_FALSE(engine_under_test_->IsRecognitionPending());
 368
 369   // TODO(primiano): In order to be very pedantic we should check that both the
 370   // upstream and downstream URL fetchers have been disposed at this time.
 371   // Unfortunately it seems that there is no direct way to detect (in tests)
 372   // if a url_fetcher has been freed or not, since they are not automatically
 373   // de-registered from the TestURLFetcherFactory on destruction.
 374 }
 375
 376 void GoogleStreamingRemoteEngineTest::InjectDummyAudioChunk() {
 377   unsigned char dummy_audio_buffer_data[2] = {'\0', '\0'};
 378   scoped_refptr<AudioChunk> dummy_audio_chunk(
 379       new AudioChunk(&dummy_audio_buffer_data[0],
 380                      sizeof(dummy_audio_buffer_data),
 381                      2 /* bytes per sample */));
 382   DCHECK(engine_under_test_.get());
 383   engine_under_test_->TakeAudioChunk(*dummy_audio_chunk.get());
 384 }
 385
 386 size_t GoogleStreamingRemoteEngineTest::UpstreamChunksUploadedFromLastCall() {
 387   TestURLFetcher* upstream_fetcher = GetUpstreamFetcher();
 388   DCHECK(upstream_fetcher);
 389   const size_t number_of_chunks = upstream_fetcher->upload_chunks().size();
 390   DCHECK_GE(number_of_chunks, last_number_of_upstream_chunks_seen_);
 391   const size_t new_chunks = number_of_chunks -
 392                             last_number_of_upstream_chunks_seen_;
 393   last_number_of_upstream_chunks_seen_ = number_of_chunks;
 394   return new_chunks;
 395 }
 396
 397 void GoogleStreamingRemoteEngineTest::ProvideMockProtoResultDownstream(
 398     const proto::SpeechRecognitionEvent& result) {
 399   TestURLFetcher* downstream_fetcher = GetDownstreamFetcher();
 400
 401   ASSERT_TRUE(downstream_fetcher);
 402   downstream_fetcher->set_status(URLRequestStatus(/* default=SUCCESS */));
 403   downstream_fetcher->set_response_code(200);
 404
 405   std::string response_string = SerializeProtobufResponse(result);
 406   response_buffer_.append(response_string);
 407   downstream_fetcher->SetResponseString(response_buffer_);
 408   downstream_fetcher->delegate()->OnURLFetchDownloadProgress(
 409       downstream_fetcher,
 410       response_buffer_.size(),
 411       -1 /* total response length not used */);
 412 }
 413
 414 void GoogleStreamingRemoteEngineTest::ProvideMockResultDownstream(
 415     const SpeechRecognitionResult& result) {
 416   proto::SpeechRecognitionEvent proto_event;
 417   proto_event.set_status(proto::SpeechRecognitionEvent::STATUS_SUCCESS);
 418   proto::SpeechRecognitionResult* proto_result = proto_event.add_result();
 419   proto_result->set_final(!result.is_provisional);
 420   for (size_t i = 0; i < result.hypotheses.size(); ++i) {
 421     proto::SpeechRecognitionAlternative* proto_alternative =
 422         proto_result->add_alternative();
 423     const SpeechRecognitionHypothesis& hypothesis = result.hypotheses[i];
 424     proto_alternative->set_confidence(hypothesis.confidence);
 425     proto_alternative->set_transcript(UTF16ToUTF8(hypothesis.utterance));
 426   }
 427   ProvideMockProtoResultDownstream(proto_event);
 428 }
 429
 430 void GoogleStreamingRemoteEngineTest::CloseMockDownstream(
 431     DownstreamError error) {
 432   TestURLFetcher* downstream_fetcher = GetDownstreamFetcher();
 433   ASSERT_TRUE(downstream_fetcher);
 434
 435   const URLRequestStatus::Status fetcher_status =
 436       (error == DOWNSTREAM_ERROR_NETWORK) ? URLRequestStatus::FAILED :
 437                                             URLRequestStatus::SUCCESS;
 438   downstream_fetcher->set_status(URLRequestStatus(fetcher_status, 0));
 439   downstream_fetcher->set_response_code(
 440       (error == DOWNSTREAM_ERROR_HTTP500) ? 500 : 200);
 441
 442   if (error == DOWNSTREAM_ERROR_WEBSERVICE_NO_MATCH) {
 443     // Send empty response.
 444     proto::SpeechRecognitionEvent response;
 445     response_buffer_.append(SerializeProtobufResponse(response));
 446   }
 447   downstream_fetcher->SetResponseString(response_buffer_);
 448   downstream_fetcher->delegate()->OnURLFetchComplete(downstream_fetcher);
 449 }
 450
 451 void GoogleStreamingRemoteEngineTest::ExpectResultsReceived(
 452     const SpeechRecognitionResults& results) {
 453   ASSERT_GE(1U, results_.size());
 454   ASSERT_TRUE(ResultsAreEqual(results, results_.front()));
 455   results_.pop();
 456 }
 457
 458 bool GoogleStreamingRemoteEngineTest::ResultsAreEqual(
 459     const SpeechRecognitionResults& a, const SpeechRecognitionResults& b) {
 460   if (a.size() != b.size())
 461     return false;
 462
 463   SpeechRecognitionResults::const_iterator it_a = a.begin();
 464   SpeechRecognitionResults::const_iterator it_b = b.begin();
 465   for (; it_a != a.end() && it_b != b.end(); ++it_a, ++it_b) {
 466     if (it_a->is_provisional != it_b->is_provisional ||
 467         it_a->hypotheses.size() != it_b->hypotheses.size()) {
 468       return false;
 469     }
 470     for (size_t i = 0; i < it_a->hypotheses.size(); ++i) {
 471       const SpeechRecognitionHypothesis& hyp_a = it_a->hypotheses[i];
 472       const SpeechRecognitionHypothesis& hyp_b = it_b->hypotheses[i];
 473       if (hyp_a.utterance != hyp_b.utterance ||
 474           hyp_a.confidence != hyp_b.confidence) {
 475         return false;
 476       }
 477     }
 478   }
 479
 480   return true;
 481 }
 482
 483 std::string GoogleStreamingRemoteEngineTest::SerializeProtobufResponse(
 484     const proto::SpeechRecognitionEvent& msg) {
 485   std::string msg_string;
 486   msg.SerializeToString(&msg_string);
 487
 488   // Prepend 4 byte prefix length indication to the protobuf message as
 489   // envisaged by the google streaming recognition webservice protocol.
 490   msg_string.insert(0, ToBigEndian32(msg_string.size()));
 491   return msg_string;
 492 }
 493
 494 std::string GoogleStreamingRemoteEngineTest::ToBigEndian32(uint32 value) {
 495   char raw_data[4];
 496   raw_data[0] = static_cast<uint8>((value >> 24) & 0xFF);
 497   raw_data[1] = static_cast<uint8>((value >> 16) & 0xFF);
 498   raw_data[2] = static_cast<uint8>((value >> 8) & 0xFF);
 499   raw_data[3] = static_cast<uint8>(value & 0xFF);
 500   return std::string(raw_data, sizeof(raw_data));
 501 }
 502
 503 }  // namespace content