Refactor UniqueNameHelper to use an adapter pattern for code sharing.

content/common/unique_name_helper.h

Index: content/common/unique_name_helper.h
diff --git a/content/renderer/unique_name_helper.h b/content/common/unique_name_helper.h
similarity index 59%
rename from content/renderer/unique_name_helper.h
rename to content/common/unique_name_helper.h
index db8beb6f7ffa1d60f99a0a893f26303c142c295e..59313c0d47a4ff8b79db5fcf57f135283473409e 100644
--- a/content/renderer/unique_name_helper.h
+++ b/content/common/unique_name_helper.h
@@ -2,22 +2,17 @@
 // 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
@@ -71,7 +66,47 @@ class RenderFrameImpl;
 // 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.
@@ -87,11 +122,11 @@ class UniqueNameHelper {
   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
@@ -100,9 +135,7 @@ class UniqueNameHelper {
   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);
@@ -110,4 +143,4 @@ class UniqueNameHelper {
 
 }  // namespace content
 
-#endif  // CONTENT_RENDERER_UNIQUE_NAME_HELPER_H_
+#endif  // CONTENT_COMMON_UNIQUE_NAME_HELPER_H_