Update BaseBindRewriters to convert base::Bind to base::BindOnce

tools/clang/base_bind_rewriters/BaseBindRewriters.cpp

 // 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.
 //
 // This file containts a clang tool to update base::Bind() callers:
 //  * Remove unneeded scoped_refptr<>::get() on method binding.
 
 #include <assert.h>
 #include <algorithm>
 #include <memory>
@@ skipping 11 matching lines @@
 #include "clang/Tooling/Tooling.h"
 #include "llvm/Support/CommandLine.h"
 #include "llvm/Support/TargetSelect.h"
 
 using namespace clang::ast_matchers;
 using clang::tooling::CommonOptionsParser;
 using Replacements = std::vector<clang::tooling::Replacement>;
 
 namespace {
 
-// Remove unneeded scoped_refptr<>::get on a receivers of method bind.
+// Replace base::Bind() to base::BindOnce() where resulting base::Callback is
+// implicitly converted into base::OnceCallback.
 // Example:
 //   // Before
-//   scoped_refptr<Foo> foo;
-//   base::Bind(&Foo::Bar, foo.get());
+//   base::PostTask(FROM_HERE, base::Bind(&Foo));
+//   base::OnceCallback<void()> cb = base::Bind(&Foo);
 //
 //   // After
-//   scoped_refptr<Foo> foo;
-//   base::Bind(&Foo::Bar, foo);
-//
-class ScopedRefptrGetRewriter : public MatchFinder::MatchCallback {
+//   base::PostTask(FROM_HERE, base::BindOnce(&Foo));
+//   base::OnceCallback<void()> cb = base::BindOnce(&Foo);
+class BindOnceRewriter : public MatchFinder::MatchCallback {
  public:
-  explicit ScopedRefptrGetRewriter(Replacements* replacements)
+  explicit BindOnceRewriter(Replacements* replacements)
       : replacements_(replacements) {}
 
   StatementMatcher GetMatcher() {
-    auto is_bind_call = callee(namedDecl(hasName("::base::Bind")));
-    auto is_method_bind = hasArgument(0, hasType(memberPointerType()));
-    auto is_raw_pointer_receiver = hasArgument(1, hasType(pointerType()));
-    auto is_scoped_refptr_get_call =
-        cxxMemberCallExpr(thisPointerType(namedDecl(hasName("scoped_refptr"))),
-                          callee(namedDecl(hasName("get"))));
-    return callExpr(is_bind_call, is_method_bind, is_raw_pointer_receiver,
-                    hasArgument(1, is_scoped_refptr_get_call),
-                    hasArgument(1, stmt().bind("target")));
+    auto is_once_callback = hasType(classTemplateSpecializationDecl(
+        hasName("::base::Callback"),
+        hasTemplateArgument(1, equalsIntegralValue("0")),
+        hasTemplateArgument(2, equalsIntegralValue("0"))));
+    auto is_repeating_callback = hasType(classTemplateSpecializationDecl(
+        hasName("::base::Callback"),
+        hasTemplateArgument(1, equalsIntegralValue("1")),
+        hasTemplateArgument(2, equalsIntegralValue("1"))));
+
+    auto bind_call =
+        callExpr(callee(namedDecl(hasName("::base::Bind")))).bind("target");
+    auto parameter_construction =
+        cxxConstructExpr(is_repeating_callback, argumentCountIs(1),
+                         hasArgument(0, ignoringImplicit(bind_call)));
+    auto constructor_conversion = cxxConstructExpr(
+        is_once_callback, argumentCountIs(1),
+        hasArgument(0, ignoringImplicit(parameter_construction)));
+    auto implicit_conversion = implicitCastExpr(
+        is_once_callback, hasSourceExpression(constructor_conversion));
+    return implicit_conversion;
   }
 
   void run(const MatchFinder::MatchResult& result) override {
-    auto* target = result.Nodes.getNodeAs<clang::CXXMemberCallExpr>("target");
-    auto* member = llvm::cast<clang::MemberExpr>(target->getCallee());
-    assert(target && member && "Unexpected match! No Expr captured!");
+    auto* target = result.Nodes.getNodeAs<clang::CallExpr>("target");
+    auto* callee = target->getCallee();
     auto range = clang::CharSourceRange::getTokenRange(
-        result.SourceManager->getSpellingLoc(member->getOperatorLoc()),
-        result.SourceManager->getSpellingLoc(target->getLocEnd()));
-
-    replacements_->emplace_back(*result.SourceManager, range, "");
+        result.SourceManager->getSpellingLoc(callee->getLocEnd()),
+        result.SourceManager->getSpellingLoc(callee->getLocEnd()));
+    replacements_->emplace_back(*result.SourceManager, range, "BindOnce");
   }
 
  private:
   Replacements* replacements_;
 };
 
 llvm::cl::extrahelp common_help(CommonOptionsParser::HelpMessage);
 
 }  // namespace.
 
 int main(int argc, const char* argv[]) {
   llvm::InitializeNativeTarget();
   llvm::InitializeNativeTargetAsmParser();
   llvm::cl::OptionCategory category(
       "Remove raw pointer on the receiver of Bind() target");
   CommonOptionsParser options(argc, argv, category);
   clang::tooling::ClangTool tool(options.getCompilations(),
                                  options.getSourcePathList());
 
   MatchFinder match_finder;
   std::vector<clang::tooling::Replacement> replacements;
 
-
-  ScopedRefptrGetRewriter scoped_refptr_rewriter(&replacements);
-  match_finder.addMatcher(scoped_refptr_rewriter.GetMatcher(),
-                          &scoped_refptr_rewriter);
+  BindOnceRewriter bind_once_rewriter(&replacements);
+  match_finder.addMatcher(bind_once_rewriter.GetMatcher(), &bind_once_rewriter);
 
   std::unique_ptr<clang::tooling::FrontendActionFactory> factory =
       clang::tooling::newFrontendActionFactory(&match_finder);
   int result = tool.run(factory.get());
   if (result != 0)
     return result;
 
   // Serialization format is documented in tools/clang/scripts/run_tool.py
   llvm::outs() << "==== BEGIN EDITS ====\n";
   for (const auto& r : replacements) {
     std::string replacement_text = r.getReplacementText().str();
     std::replace(replacement_text.begin(), replacement_text.end(), '\n', '\0');
     llvm::outs() << "r:::" << r.getFilePath() << ":::" << r.getOffset()
                  << ":::" << r.getLength() << ":::" << replacement_text << "\n";
   }
   llvm::outs() << "==== END EDITS ====\n";
 
   return 0;
 }