[Chromecast] Adding pause/resume operations to VideoPlaneController.

chromecast/base/cast_resource.h

 // Copyright 2015 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.
 
 #ifndef CHROMECAST_BASE_CAST_RESOURCE_H_
 #define CHROMECAST_BASE_CAST_RESOURCE_H_
 
 #include "base/macros.h"
 
 namespace chromecast {
@@ skipping 35 matching lines @@
     //            returned, Client will remove the resource from its watching
     //            list.
     virtual void OnResourceReleased(CastResource* cast_resource,
                                     Resource remain) = 0;
 
    protected:
     virtual ~Client() {}
   };
 
   void SetCastResourceClient(Client* client);
+  // Called to initialize resources after OEM has granted them, and before
+  // they start getting used by consumers. Implementation must be synchronous
+  // since consumers will start using the resource immediately afterwards.
+  virtual void InitializeResource(Resource resource) = 0;

[derekjchow1, 2015/12/15 22:40:35]

What thread does this get called on? If this gets called on the UI thread we
should make this API asynchronous in case if initialization becomes a long
operation.

Also another reason to make this asynchronous would be to mirror
ReleaseResource().

[yucliu1, 2015/12/15 23:05:58]

Probably we can make a contract here: InitializeResource should have a
corresponding Client::OnResourceAcquired. This requires add other two APIs to
add/remove CastResource to/from watch list.

Otherwise, this function may not be called, right? Can you add comments here?

[esum, 2015/12/17 08:28:12]

Agreed it should be made asynchronous, but I would really like to tackle this
after 1.18 in the interest of fixing the actual bug at hand for OEM's soon.
Especially because this is not sounding like a straightforward change. I think
Tavis has some thoughts on this also.

Is there a problem with the way the code is now? I know it's not ideal, but it's
simple and all the VideoPlane calls are very quick.

Also Luke/Gaofeng, what do you think?

[halliwell, 2015/12/17 14:46:31]

Calling VideoPlane synchronously is fine.  I'm ok with following up on async API
afterwards.

   // Called to release resources. Implementation should call
   // Client::OnResourceReleased when resource is released on its side.
   virtual void ReleaseResource(Resource resource) = 0;
 
  protected:
   CastResource() : client_(nullptr) {}
   virtual ~CastResource() {}
 
   void NotifyResourceAcquired();
   void NotifyResourceReleased(Resource remain);
 
  private:
   Client* client_;
 
   DISALLOW_COPY_AND_ASSIGN(CastResource);
 };
 
 }  // namespace chromecast
 
 #endif