Motown: Move responsibility for binding to MediaFactoryService::Product

services/media/factory_service/factory_service.h

 // 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.
 
 #ifndef MOJO_SERVICES_MEDIA_FACTORY_FACTORY_SERVICE_H_
 #define MOJO_SERVICES_MEDIA_FACTORY_FACTORY_SERVICE_H_
 
 #include <unordered_set>
 
 #include "mojo/common/binding_set.h"
 #include "mojo/public/cpp/application/application_delegate.h"
 #include "mojo/public/cpp/application/application_impl.h"
 #include "mojo/services/media/control/interfaces/media_factory.mojom.h"
 
 namespace mojo {
 namespace media {
 
 class MediaFactoryService : public ApplicationDelegate,
                             public InterfaceFactory<MediaFactory>,
                             public MediaFactory {
  public:
   // Provides common behavior for all objects created by the factory service.
-  class Product : public std::enable_shared_from_this<Product> {
+  class ProductBase : public std::enable_shared_from_this<ProductBase> {
    public:
-    virtual ~Product();
+    virtual ~ProductBase();
 
    protected:
-    Product(MediaFactoryService* owner);
+    ProductBase(MediaFactoryService* owner);
 
     // Returns the ApplicationImpl.
     ApplicationImpl* app() {
       DCHECK(owner_->app_);
       return owner_->app_;
     }
 
     // Tells the factory service to release this product.
     void ReleaseFromOwner() {
       size_t erased = owner_->products_.erase(shared_from_this());
       DCHECK(erased);
     }
 
    private:
     MediaFactoryService* owner_;
   };
 
+  template <typename Interface>
+  class Product : public ProductBase {
+   public:
+    virtual ~Product() {}
+
+   protected:
+    Product(Interface* impl,
+            InterfaceRequest<Interface> request,
+            MediaFactoryService* owner)
+        : ProductBase(owner), binding_(impl, request.Pass()) {
+      DCHECK(impl);
+      binding_.set_connection_error_handler([this]() { ReleaseFromOwner(); });
+    }
+
+    // Closes the binding and calls ReleaseFromOwner.
+    void UnbindAndReleaseFromOwner() {
+      if (binding_.is_bound()) {
+        binding_.Close();
+      }
+
+      ReleaseFromOwner();
+    }
+
+   private:
+    Binding<Interface> binding_;
+  };
+
   MediaFactoryService();
 
   ~MediaFactoryService() override;
 
   // ApplicationDelegate implementation.
   void Initialize(ApplicationImpl* app) override;
 
   bool ConfigureIncomingConnection(ApplicationConnection* connection) override;
 
   // InterfaceFactory<MediaFactory> implementation.
@@ skipping 17 matching lines @@
 
   void CreateDecoder(MediaTypePtr input_media_type,
                      InterfaceRequest<MediaTypeConverter> decoder) override;
 
   void CreateNetworkReader(const String& url,
                            InterfaceRequest<SeekingReader> reader) override;
 
  private:
   BindingSet<MediaFactory> bindings_;
   ApplicationImpl* app_;
-  std::unordered_set<std::shared_ptr<Product>> products_;
+  std::unordered_set<std::shared_ptr<ProductBase>> products_;
 };
 
+// For use by products when handling mojo requests.
+// Checks the condition, and, if it's false, unbinds, releases from the owner
+// and calls return. Doesn't support stream arguments.
+// TODO(dalesat): Support stream arguments.
+#define RCHECK(condition)                                         \
+  if (!(condition)) {                                             \
+    LOG(ERROR) << "request precondition failed: " #condition "."; \
+    UnbindAndReleaseFromOwner();                                  \
+    return;                                                       \
+  }
+
 }  // namespace media
 }  // namespace mojo
 
 #endif  // MOJO_SERVICES_MEDIA_FACTORY_FACTORY_SERVICE_H_