Use explicit flush for ArcVideoAccelerator.

chrome/gpu/gpu_arc_video_service.cc

 // Copyright 2016 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 "chrome/gpu/gpu_arc_video_service.h"
 
 #include <fcntl.h>
 
 #include <utility>
 
 #include "base/bind.h"
 #include "base/logging.h"
 #include "base/thread_task_runner_handle.h"
 #include "chrome/gpu/arc_gpu_video_decode_accelerator.h"
 #include "chrome/gpu/arc_video_accelerator.h"
 #include "components/arc/common/video_accelerator.mojom.h"
 #include "mojo/edk/embedder/embedder.h"
 #include "mojo/public/cpp/bindings/binding.h"
 #include "mojo/public/cpp/bindings/type_converter.h"
 
 namespace mojo {
 
 template <>
 struct TypeConverter<arc::mojom::BufferMetadataPtr,
                      chromeos::arc::BufferMetadata> {
   static arc::mojom::BufferMetadataPtr Convert(
       const chromeos::arc::BufferMetadata& input) {
     arc::mojom::BufferMetadataPtr result = arc::mojom::BufferMetadata::New();
     result->timestamp = input.timestamp;
-    result->flags = input.flags;
     result->bytes_used = input.bytes_used;
     return result;
   }
 };
 
 template <>
 struct TypeConverter<chromeos::arc::BufferMetadata,
                      arc::mojom::BufferMetadataPtr> {
   static chromeos::arc::BufferMetadata Convert(
       const arc::mojom::BufferMetadataPtr& input) {
     chromeos::arc::BufferMetadata result;
     result.timestamp = input->timestamp;
-    result.flags = input->flags;
     result.bytes_used = input->bytes_used;
     return result;
   }
 };
 
 template <>
 struct TypeConverter<arc::mojom::VideoFormatPtr, chromeos::arc::VideoFormat> {
   static arc::mojom::VideoFormatPtr Convert(
       const chromeos::arc::VideoFormat& input) {
     arc::mojom::VideoFormatPtr result = arc::mojom::VideoFormat::New();
@@ skipping 91 matching lines @@
     DVLOG(2) << "OnBufferDone " << port << "," << index;
     client_->OnBufferDone(static_cast<::arc::mojom::PortType>(port), index,
                           ::arc::mojom::BufferMetadata::From(metadata));
   }
 
   void OnResetDone() override {
     DVLOG(2) << "OnResetDone";
     client_->OnResetDone();
   }
 
+  void OnFlushDone() override {
+    DVLOG(2) << "OnFlushDone";
+    client_->OnFlushDone();
+  }
+
   void OnOutputFormatChanged(const VideoFormat& format) override {
     DVLOG(2) << "OnOutputFormatChanged";
     client_->OnOutputFormatChanged(::arc::mojom::VideoFormat::From(format));
   }
 
   // ::arc::mojom::VideoAcceleratorService impementation.
   void Initialize(::arc::mojom::ArcVideoAcceleratorConfigPtr config,
                   const InitializeCallback& callback) override {
     DVLOG(2) << "Initialize";
     bool result = accelerator_->Initialize(
@@ skipping 41 matching lines @@
                             metadata.To<BufferMetadata>());
   }
 
   void SetNumberOfOutputBuffers(uint32_t number) override {
     DVLOG(2) << "SetNumberOfOutputBuffers number=" << number;
     accelerator_->SetNumberOfOutputBuffers(number);
   }
 
   void Reset() override { accelerator_->Reset(); }
 
+  void Flush() override { accelerator_->Flush(); }
+
  private:
   base::ThreadChecker thread_checker_;
   GpuArcVideoService* const owner_;
   std::unique_ptr<ArcVideoAccelerator> accelerator_;
   ::arc::mojom::VideoAcceleratorServiceClientPtr client_;
   mojo::Binding<::arc::mojom::VideoAcceleratorService> binding_;
 };
 
 GpuArcVideoService::GpuArcVideoService(
     mojo::InterfaceRequest<::arc::mojom::VideoHost> request)
@@ skipping 30 matching lines @@
 
   callback.Run(mojo::ScopedHandle(mojo::Handle(wrapped_handle)), token);
 }
 
 void GpuArcVideoService::RemoveClient(AcceleratorStub* stub) {
   accelerator_stubs_.erase(stub);
 }
 
 }  // namespace arc
 }  // namespace chromeos