Index: tools/clang/value_cleanup/tests/list-value-append-expected.cc |
diff --git a/tools/clang/value_cleanup/tests/list-value-append-expected.cc b/tools/clang/value_cleanup/tests/list-value-append-expected.cc |
index ad347f43baf5be71111139c38c22534fee4a1f1d..1de3ff61d8fd37138903ba2f3cfea0ea6f26bcb6 100644 |
--- a/tools/clang/value_cleanup/tests/list-value-append-expected.cc |
+++ b/tools/clang/value_cleanup/tests/list-value-append-expected.cc |
@@ -8,10 +8,17 @@ |
#define true true |
+base::ListValue* ReturnsRawPtr() { |
+ return nullptr; |
+} |
+ |
std::unique_ptr<base::Value> ReturnsUniquePtr() { |
return nullptr; |
} |
+// The joy of raw pointers. |
+void DoesItTakeOwnership(base::Value*) {} |
+ |
struct Thing { |
std::unique_ptr<base::Value> ToValue() { return nullptr; } |
}; |
@@ -30,3 +37,73 @@ void F() { |
std::unique_ptr<base::Value> unique_ptr_var; |
list.Append(std::move(unique_ptr_var)); |
} |
+ |
+void G(base::Value* input) { |
+ base::ListValue list; |
+ |
+ std::unique_ptr<base::ListValue> local(new base::ListValue()); |
+ // Not rewritten, since it often makes more sense to change the function |
+ // prototype. |
+ local->Append(input); |
+ // Should be rewritten: it will only be moved after it's no longer referenced. |
+ list.Append(std::move(local)); |
+ |
+ // Not rewritten, since it would be used after it's moved. In theory, we could |
+ // automatically handle this too, but the risk of accidentally breaking |
+ // something is much higher. |
+ base::ListValue* clever_list = new base::ListValue; |
+ list.Append(clever_list); |
+ clever_list->AppendInteger(2); |
+ |
+ // Not rewritten, since it often makes more sense to change the function |
+ // prototype. |
+ base::Value* returned_value = ReturnsRawPtr(); |
+ list.Append(returned_value); |
+ |
+ // Should be rewritten. The reassignment should be transformed into |
+ // .reset(). |
+ std::unique_ptr<base::ListValue> reused_list(new base::ListValue); |
+ reused_list->AppendInteger(1); |
+ list.Append(std::move(reused_list)); |
+ reused_list.reset(new base::ListValue); |
+ reused_list->AppendInteger(3); |
+ list.Append(std::move(reused_list)); |
+ |
+ // This shouldn't be rewritten, since the reassignment is the return |
+ // value of a function. |
+ base::ListValue* reused_list_2 = new base::ListValue; |
+ reused_list_2->AppendInteger(4); |
+ list.Append(reused_list_2); |
+ reused_list_2 = ReturnsRawPtr(); |
+ reused_list_2->AppendInteger(5); |
+ list.Append(reused_list_2); |
+ |
+ // auto should be expanded to a std::unique_ptr containing the deduced type. |
+ std::unique_ptr<class base::ListValue> auto_list(new base::ListValue); |
+ auto_list->AppendInteger(6); |
+ list.Append(std::move(auto_list)); |
+ |
+ std::unique_ptr<class base::ListValue> auto_list_2(new base::ListValue); |
+ auto_list_2->AppendInteger(7); |
+ list.Append(std::move(auto_list_2)); |
+ |
+ // Shouldn't be rewritten: a raw pointer is passed to a function which may or |
+ // may not take ownership. |
+ base::ListValue* maybe_owned_list = new base::ListValue; |
+ DoesItTakeOwnership(maybe_owned_list); |
+ list.Append(maybe_owned_list); |
+ |
+ // Should be rewritten, even though it doesn't have an initializer. |
+ std::unique_ptr<base::ListValue> list_with_no_initializer; |
+ list_with_no_initializer.reset(new base::ListValue); |
+ list.Append(std::move(list_with_no_initializer)); |
+ |
+ // Make sure C++98 style initialization is correctly handled. |
+ std::unique_ptr<base::ListValue> cxx98_list(new base::ListValue); |
+ list.Append(std::move(cxx98_list)); |
+ |
+ // C++11 style syntax currently causes the tool to bail out: this is banned in |
+ // Chromium style anyway. |
+ base::ListValue* cxx11_list{new base::ListValue}; |
+ list.Append(cxx11_list); |
+} |