Adds an AccessPolicy that is queried to determine what a connection can do

mojo/services/view_manager/view_manager_service_impl.h

 // Copyright 2014 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_VIEW_MANAGER_VIEW_MANAGER_SERVICE_IMPL_H_
 #define MOJO_SERVICES_VIEW_MANAGER_VIEW_MANAGER_SERVICE_IMPL_H_
 
 #include <set>
 #include <string>
 #include <vector>
 
 #include "base/basictypes.h"
 #include "base/compiler_specific.h"
 #include "base/containers/hash_tables.h"
+#include "base/memory/scoped_ptr.h"
 #include "mojo/services/public/interfaces/view_manager/view_manager.mojom.h"
+#include "mojo/services/view_manager/access_policy_delegate.h"
 #include "mojo/services/view_manager/ids.h"
 #include "mojo/services/view_manager/view_manager_export.h"
 
 namespace gfx {
 class Rect;
 }
 
 namespace mojo {
 namespace service {
 
+class AccessPolicy;
 class Node;
 class RootNodeManager;
 class View;
 
 #if defined(OS_WIN)
 // Equivalent of NON_EXPORTED_BASE which does not work with the template snafu
 // below.
 #pragma warning(push)
 #pragma warning(disable : 4275)
 #endif
 
 // Manages a connection from the client.
 class MOJO_VIEW_MANAGER_EXPORT ViewManagerServiceImpl
-    : public InterfaceImpl<ViewManagerService> {
+    : public InterfaceImpl<ViewManagerService>,
+      public AccessPolicyDelegate {
  public:
   ViewManagerServiceImpl(RootNodeManager* root_node_manager,
                          ConnectionSpecificId creator_id,
                          const std::string& creator_url,
                          const std::string& url,
                          const NodeId& root_id);
   virtual ~ViewManagerServiceImpl();
 
   // Used to mark this connection as originating from a call to
   // ViewManagerService::Connect(). When set OnConnectionError() deletes |this|.
@@ skipping 51 matching lines @@
   // TODO(sky): move this to private section (currently can't because of
   // bindings).
   // InterfaceImp overrides:
   virtual void OnConnectionError() MOJO_OVERRIDE;
 
  private:
   typedef std::map<ConnectionSpecificId, Node*> NodeMap;
   typedef std::map<ConnectionSpecificId, View*> ViewMap;
   typedef base::hash_set<Id> NodeIdSet;
 
+  bool IsNodeKnown(const Node* node) const;
+
   // These functions return true if the corresponding mojom function is allowed
   // for this connection.
-  bool CanRemoveNodeFromParent(const Node* node) const;
-  bool CanAddNode(const Node* parent, const Node* child) const;
   bool CanReorderNode(const Node* node,
                       const Node* relative_node,
                       OrderDirection direction) const;
-  bool CanDeleteNode(const NodeId& node_id) const;
-  bool CanDeleteView(const ViewId& view_id) const;
-  bool CanSetView(const Node* node, const ViewId& view_id) const;
-  bool CanSetFocus(const Node* node) const;
-  bool CanGetNodeTree(const Node* node) const;
-  bool CanEmbed(Id transport_node_id) const;
-  bool CanSetNodeVisibility(const Node* node, bool visible) const;
-  // Used during GetNodeTreeImpl() to decide if we should descend into |node|
-  // when building the results of GetNodeTree().
-  bool CanDescendIntoNodeForNodeTree(const Node* node) const;
 
   // Deletes a node owned by this connection. Returns true on success. |source|
   // is the connection that originated the change.
-  bool DeleteNodeImpl(ViewManagerServiceImpl* source, const NodeId& node_id);
+  bool DeleteNodeImpl(ViewManagerServiceImpl* source, Node* node);
 
   // Deletes a view owned by this connection. Returns true on success. |source|
   // is the connection that originated the change.
-  bool DeleteViewImpl(ViewManagerServiceImpl* source, const ViewId& view_id);
+  bool DeleteViewImpl(ViewManagerServiceImpl* source, View* view);
 
   // Sets the view associated with a node.
-  bool SetViewImpl(Node* node, const ViewId& view_id);
+  bool SetViewImpl(Node* node, View* view);
 
   // If |node| is known (in |known_nodes_|) does nothing. Otherwise adds |node|
   // to |nodes|, marks |node| as known and recurses.
   void GetUnknownNodesFrom(const Node* node, std::vector<const Node*>* nodes);
 
-  // Returns true if node (or one of its ancestors) is embedded in another
-  // connection.
-  bool IsNodeEmbeddedInAnotherConnection(const Node* node) const;
-
   // Removes |node| and all its descendants from |known_nodes_|. This does not
   // recurse through nodes that were created by this connection. All nodes owned
   // by this connection are added to |local_nodes|.
   void RemoveFromKnown(const Node* node, std::vector<Node*>* local_nodes);
 
   // Adds |node_id| to the set of roots this connection knows about. The caller
   // should have verified |node_id| is not among the roots of this connection.
   void AddRoot(const NodeId& node_id);
 
   // Removes |node_id| from the set of roots this connection knows about.
   void RemoveRoot(const NodeId& node_id);
 
   void RemoveChildrenAsPartOfEmbed(const NodeId& node_id);
 
-  // Returns true if |node| is a non-null and a descendant of |roots_| (or
-  // |roots_| is empty).
-  bool IsNodeDescendantOfRoots(const Node* node) const;
-
-  // Returns true if notification should be sent of a hierarchy change. If true
-  // is returned, any nodes that need to be sent to the client are added to
-  // |to_send|.
-  bool ShouldNotifyOnHierarchyChange(const Node* node,
-                                     const Node** new_parent,
-                                     const Node** old_parent,
-                                     std::vector<const Node*>* to_send);
-
   // Converts an array of Nodes to NodeDatas. This assumes all the nodes are
   // valid for the client. The parent of nodes the client is not allowed to see
   // are set to NULL (in the returned NodeDatas).
   Array<NodeDataPtr> NodesToNodeDatas(const std::vector<const Node*>& nodes);
 
   // Implementation of GetNodeTree(). Adds |node| to |nodes| and recurses if
   // CanDescendIntoNodeForNodeTree() returns true.
   void GetNodeTreeImpl(const Node* node, std::vector<const Node*>* nodes) const;
 
   // ViewManagerService:
@@ skipping 32 matching lines @@
                              const Callback<void(bool)>& callback) OVERRIDE;
   virtual void SetNodeVisibility(Id transport_node_id,
                                  bool visible,
                                  const Callback<void(bool)>& callback) OVERRIDE;
   virtual void Embed(const String& url,
                      Id transport_node_id,
                      const Callback<void(bool)>& callback) OVERRIDE;
   virtual void DispatchOnViewInputEvent(Id transport_view_id,
                                         EventPtr event) OVERRIDE;
 
-  // InterfaceImp overrides:
+  // InterfaceImp:

[Ben Goodger (Google), 2014/07/25 20:51:46]

InterfaceImpl

[sky, 2014/07/25 21:10:46]

Done.

   virtual void OnConnectionEstablished() MOJO_OVERRIDE;
 
+  // AccessPolicyDelegate:
+  virtual const base::hash_set<Id>& GetRootsForAccessPolicy() const OVERRIDE;
+  virtual bool IsNodeKnownForAccessPolicy(const Node* node) const OVERRIDE;
+  virtual bool IsNodeEmbeddedInAnotherConnectionForAccessPolicy(
+      const Node* node) const OVERRIDE;
+
   RootNodeManager* root_node_manager_;
 
   // Id of this connection as assigned by RootNodeManager.
   const ConnectionSpecificId id_;
 
   // URL this connection was created for.
   const std::string url_;
 
   // ID of the connection that created us. If 0 it indicates either we were
   // created by the root, or the connection that created us has been destroyed.
   ConnectionSpecificId creator_id_;
 
   // The URL of the app that embedded the app this connection was created for.
   const std::string creator_url_;
 
+  scoped_ptr<AccessPolicy> access_policy_;
+
   // The nodes and views created by this connection. This connection owns these
   // objects.
   NodeMap node_map_;
   ViewMap view_map_;
 
   // The set of nodes that has been communicated to the client.
   NodeIdSet known_nodes_;
 
   // This is the set of nodes the connection can parent nodes to (in addition to
   // any nodes created by this connection). If empty the connection can
@@ skipping 10 matching lines @@
 };
 
 #if defined(OS_WIN)
 #pragma warning(pop)
 #endif
 
 }  // namespace service
 }  // namespace mojo
 
 #endif  // MOJO_SERVICES_VIEW_MANAGER_VIEW_MANAGER_SERVICE_IMPL_H_