Refactor UniqueNameHelper to use an adapter pattern for code sharing.

content/common/unique_name_helper.h

 // Copyright 2017 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 CONTENT_RENDERER_UNIQUE_NAME_HELPER_H_
-#define CONTENT_RENDERER_UNIQUE_NAME_HELPER_H_
+#ifndef CONTENT_COMMON_UNIQUE_NAME_HELPER_H_
+#define CONTENT_COMMON_UNIQUE_NAME_HELPER_H_
 
 #include <string>
+#include <vector>
 
 #include "base/macros.h"
-
-namespace blink {
-class WebFrame;
-class WebLocalFrame;
-}  // namespace blink
+#include "base/strings/string_piece.h"
 
 namespace content {
 
-class RenderFrameImpl;
-
 // Frame helper that manages the details of generating a quasi-stable unique
 // name for the frame. The name is unique within a page, and is used for:
 // - matching up session history items with recreated frames
 // - layout test results
 //
 // Description of the current unique name format
 // ---------------------------------------------
 // Changing the format of unique name has a high cost, because it breaks
 // backwards compatibility of session history (which stores unique names
 // generated in the past on user's disk). The evolution of unique name in a
@@ skipping 33 matching lines @@
 //     |                    #1                   | #2 |  #3  |
 //
 // newUniqueSuffix ::= "<!--framePosition" framePosition "/" retryNumber "-->"
 //
 // framePosition ::= "-" numberOfSiblingsBeforeChild
 //                   [ framePosition-forParent? ]
 //
 // retryNumber ::= smallest non-negative integer resulting in unique name
 class UniqueNameHelper {
  public:
-  explicit UniqueNameHelper(RenderFrameImpl* render_frame);
+  // Adapter class so UniqueNameHelper can be used with both RenderFrameImpl and
+  // ExplodedFrameState.
+  class FrameAdapter {
+   public:
+    FrameAdapter() {}
+    virtual ~FrameAdapter();
+
+    virtual bool IsMainFrame() const = 0;
+    virtual bool IsCandidateUnique(const std::string& name) const = 0;
+    virtual int GetSiblingCount() const = 0;
+    virtual int GetChildCount() const = 0;
+    // Sets the reference point for iterations that walk up the frame tree.
+    enum class BeginPoint {
+      // This should be the default: it indicates the logical iteration
+      // operation began on the current frame of this adapter and the walking
+      // logic should retrieve the parent frame as normal.
+      kParentFrame,
+      // For implementing the pending child frame adapter, which delegates to
+      // its future parent's FrameAdapter. Walking up the tree should not skip
+      // the currrent frame associated with this adapter; instead it should
+      // treat the adapter's current frame as the parent, as the logical
+      // iteration began with the pending child.
+      kThisFrame,
+    };
+    // Returns a vector of the names of ancestor frames, ordered from root down.
+    // |begin_point| indicates the reference point for starting the collection,
+    // and |should_stop| is a boolean predicate that indicates when to stop
+    // collection of names.
+    virtual std::vector<base::StringPiece> CollectAncestorNames(
+        BeginPoint begin_point,
+        bool (*should_stop)(base::StringPiece)) const = 0;
+    // Returns a vector of ints representing the child index of each frame in
+    // the chain from this frame to the root (note that this order is opposite
+    // to that of CollectAncestorNames).
+    virtual std::vector<int> GetFramePosition(BeginPoint begin_point) const = 0;
+
+   private:
+    DISALLOW_COPY_AND_ASSIGN(FrameAdapter);
+  };
+
+  explicit UniqueNameHelper(FrameAdapter* frame);
   ~UniqueNameHelper();
 
   // Returns the generated unique name.
   const std::string& value() const { return unique_name_; }
 
   // Used to propagate an already calculated unique name.
   //
   // TODO(lukasza): It would be nice to assert uniqueness of the propagated
   // name here but:
   // 1) uniqueness is currently violated by provisional/old frame pairs.
   // 2) there is an unresolved race between 2 OOPIFs, that can result in a
   //    non-unique unique name: see https://crbug.com/558680#c14.
   void set_propagated_name(const std::string& name) { unique_name_ = name; }
 
   // Note: when creating a new child frame, the unique name needs to be
-  // calculated before the RenderFrameImpl is created. To avoid this chicken and
-  // egg problem, this method is static, which means that |parent| needs to be
-  // passed as a parameter.
-  static std::string GenerateNameForNewChildFrame(blink::WebFrame* parent,
-                                                  const std::string& name);
+  // calculated before the child frame is created. To avoid this chicken and
+  // egg problem, this method is designed to be call on the *parent* frame of

[Łukasz Anforowicz, 2017/05/25 16:48:49]

nit: s/call/called/ ?

[dcheng, 2017/05/25 18:25:03]

Done.

+  // the future new child frame and return the value the new child frame should
+  // use.
+  std::string GenerateNameForNewChildFrame(const std::string& name) const;
 
   // Called after a browsing context name change to generate a new name. Note
   // that this should not be called if the frame is no longer displaying the
   // initial empty document, as unique name changes after that point will break
   // history navigations. See https://crbug.com/607205.
   void UpdateName(const std::string& name);
 
  private:
-  blink::WebLocalFrame* GetWebFrame() const;
-
-  RenderFrameImpl* const render_frame_;
+  FrameAdapter* const frame_;
   std::string unique_name_;
 
   DISALLOW_COPY_AND_ASSIGN(UniqueNameHelper);
 };
 
 }  // namespace content
 
-#endif  // CONTENT_RENDERER_UNIQUE_NAME_HELPER_H_
+#endif  // CONTENT_COMMON_UNIQUE_NAME_HELPER_H_