Update from https://crrev.com/312398
Involves adding many //testing/test.gni imports, fixing one
SkSurface::NewRenderTarget invocation inside sky, and fixing up
base::Process usage in the shell.
Review URL: https://codereview.chromium.org/862133002
diff --git a/BUILD.gn b/BUILD.gn
index cb914be..065f871 100644
--- a/BUILD.gn
+++ b/BUILD.gn
@@ -3,6 +3,7 @@
# found in the LICENSE file.
import("//build/config/ui.gni")
+import("//testing/test.gni")
if (is_android) {
import("//build/config/android/rules.gni")
@@ -909,7 +910,10 @@
# Linux.
if (is_linux) {
# TODO(brettw) this will need to be parameterized at some point.
- linux_configs = [ "//build/config/linux:glib" ]
+ linux_configs = []
+ if (use_glib) {
+ linux_configs += [ "//build/config/linux:glib" ]
+ }
configs += linux_configs
all_dependent_configs = linux_configs
@@ -1374,6 +1378,13 @@
"//third_party/icu",
]
+ if (is_android) {
+ apk_deps = [
+ ":base_java",
+ ":base_java_unittest_support",
+ ]
+ }
+
if (is_ios) {
sources -= [
"metrics/stats_table_uinittest.cc", # Requires spawning a process.
@@ -1403,10 +1414,12 @@
sources -= [ "file_version_info_unittest.cc" ]
sources += [ "nix/xdg_util_unittest.cc" ]
defines = [ "USE_SYMBOLIZE" ]
- configs += [ "//build/config/linux:glib" ]
+ if (use_glib) {
+ configs += [ "//build/config/linux:glib" ]
+ }
}
- if (!is_linux) {
+ if (!is_linux || use_ozone) {
sources -= [ "message_loop/message_pump_glib_unittest.cc" ]
}
@@ -1526,14 +1539,4 @@
java_files =
[ "test/android/java/src/org/chromium/base/ContentUriTestUtils.java" ]
}
-
- # GYP: //base.gyp:base_unittests_apk
- unittest_apk("base_unittests_apk") {
- deps = [
- ":base_java",
- ":base_java_unittest_support",
- ":base_unittests",
- ]
- unittests_dep = ":base_unittests"
- }
}
diff --git a/DEPS b/DEPS
index 2407baa..c632e35 100644
--- a/DEPS
+++ b/DEPS
@@ -4,7 +4,6 @@
"+third_party/apple_apsl",
"+third_party/libevent",
"+third_party/dmg_fp",
- "+third_party/google_toolbox_for_mac/src",
"+third_party/mach_override",
"+third_party/modp_b64",
"+third_party/tcmalloc",
diff --git a/allocator/generic_allocators.cc b/allocator/generic_allocators.cc
index 2726903..ae65f77 100644
--- a/allocator/generic_allocators.cc
+++ b/allocator/generic_allocators.cc
@@ -28,7 +28,7 @@
return generic_cpp_alloc(size, false);
}
-void operator delete(void* p) {
+void operator delete(void* p) throw() {
free(p);
}
@@ -36,7 +36,7 @@
return generic_cpp_alloc(size, false);
}
-void operator delete[](void* p) {
+void operator delete[](void* p) throw() {
free(p);
}
@@ -44,7 +44,7 @@
return generic_cpp_alloc(size, true);
}
-void operator delete(void* p, const std::nothrow_t& nt) {
+void operator delete(void* p, const std::nothrow_t& nt) throw() {
free(p);
}
@@ -52,7 +52,7 @@
return generic_cpp_alloc(size, true);
}
-void operator delete[](void* p, const std::nothrow_t& nt) {
+void operator delete[](void* p, const std::nothrow_t& nt) throw() {
free(p);
}
@@ -83,10 +83,6 @@
return result;
}
-void cfree(void* p) {
- free(p);
-}
-
#ifdef WIN32
void* _recalloc(void* p, size_t n, size_t elem_size) {
diff --git a/android/java/src/org/chromium/base/PerfTraceEvent.java b/android/java/src/org/chromium/base/PerfTraceEvent.java
index ca22042..c0e4b21 100644
--- a/android/java/src/org/chromium/base/PerfTraceEvent.java
+++ b/android/java/src/org/chromium/base/PerfTraceEvent.java
@@ -8,6 +8,8 @@
import android.os.Debug.MemoryInfo;
import android.util.Log;
+import org.chromium.base.annotations.SuppressFBWarnings;
+
import org.json.JSONArray;
import org.json.JSONException;
import org.json.JSONObject;
@@ -36,6 +38,7 @@
* the @TracePerf annotation. Thus, unlike TraceEvent, we do not
* support an implicit trace name based on the callstack.
*/
+@SuppressFBWarnings("CHROMIUM_SYNCHRONIZED_METHOD")
public class PerfTraceEvent {
private static final int MAX_NAME_LENGTH = 40;
private static final String MEMORY_TRACE_NAME_SUFFIX = "_BZR_PSS";
diff --git a/android/java/src/org/chromium/base/annotations/SuppressFBWarnings.java b/android/java/src/org/chromium/base/annotations/SuppressFBWarnings.java
new file mode 100644
index 0000000..89068ac
--- /dev/null
+++ b/android/java/src/org/chromium/base/annotations/SuppressFBWarnings.java
@@ -0,0 +1,20 @@
+// 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.
+
+package org.chromium.base.annotations;
+
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+
+/**
+ * @SuppressFBWarnings is used to suppress FindBugs warnings.
+ *
+ * The long name of FindBugs warnings can be found at
+ * http://findbugs.sourceforge.net/bugDescriptions.html
+ */
+@Retention(RetentionPolicy.CLASS)
+public @interface SuppressFBWarnings {
+ String[] value() default {};
+ String justification() default "";
+}
diff --git a/android/java/src/org/chromium/base/library_loader/Linker.java b/android/java/src/org/chromium/base/library_loader/Linker.java
index d58d1fc..dfcc141 100644
--- a/android/java/src/org/chromium/base/library_loader/Linker.java
+++ b/android/java/src/org/chromium/base/library_loader/Linker.java
@@ -845,6 +845,16 @@
*/
public static boolean checkMapExecSupport(String apkFile) {
assert apkFile != null;
+
+ // https://code.google.com/p/chromium/issues/detail?id=448084
+ // Do not check if the device is Samsung Mega.
+ final String model = android.os.Build.MODEL;
+ if (model != null && model.equals("GT-I9205")) {
+ if (DEBUG) Log.i(TAG, "checkMapExecSupport: model is '" + model
+ + "', returning false");
+ return false;
+ }
+
synchronized (Linker.class) {
ensureInitializedLocked();
diff --git a/android/java/templates/NativeLibraries.template b/android/java/templates/NativeLibraries.template
index f52acb4..d9f6a55 100644
--- a/android/java/templates/NativeLibraries.template
+++ b/android/java/templates/NativeLibraries.template
@@ -4,6 +4,9 @@
package org.chromium.base.library_loader;
+import org.chromium.base.annotations.SuppressFBWarnings;
+
+@SuppressFBWarnings
public class NativeLibraries {
/**
* IMPORTANT NOTE: The variables defined here must _not_ be 'final'.
diff --git a/atomicops.h b/atomicops.h
index 833e170..6a5371c 100644
--- a/atomicops.h
+++ b/atomicops.h
@@ -28,10 +28,14 @@
#ifndef BASE_ATOMICOPS_H_
#define BASE_ATOMICOPS_H_
-#include <cassert> // Small C++ header which defines implementation specific
- // macros used to identify the STL implementation.
#include <stdint.h>
+// Small C++ header which defines implementation specific macros used to
+// identify the STL implementation.
+// - libc++: captures __config for _LIBCPP_VERSION
+// - libstdc++: captures bits/c++config.h for __GLIBCXX__
+#include <cstddef>
+
#include "base/base_export.h"
#include "build/build_config.h"
diff --git a/base.gyp b/base.gyp
index 4d5ac00..5d26fc4 100644
--- a/base.gyp
+++ b/base.gyp
@@ -757,6 +757,11 @@
'message_loop/message_pump_glib_unittest.cc',
]
}],
+ ['use_ozone == 1', {
+ 'sources!': [
+ 'message_loop/message_pump_glib_unittest.cc',
+ ]
+ }],
['OS == "linux" and use_allocator!="none"', {
'dependencies': [
'allocator/allocator.gyp:allocator',
diff --git a/base.gypi b/base.gypi
index 14a632d..349308c 100644
--- a/base.gypi
+++ b/base.gypi
@@ -941,6 +941,11 @@
'strings/string16.cc',
],
},],
+ ['<(use_ozone) == 1', {
+ 'sources!': [
+ 'message_loop/message_pump_glib.cc',
+ ]
+ }],
['OS == "linux" and >(nacl_untrusted_build)==0', {
'sources!': [
'files/file_path_watcher_fsevents.cc',
diff --git a/cancelable_callback.h b/cancelable_callback.h
index 91eb046..2b9d260 100644
--- a/cancelable_callback.h
+++ b/cancelable_callback.h
@@ -62,8 +62,7 @@
// |callback| must not be null.
explicit CancelableCallback(const base::Callback<void(A...)>& callback)
- : weak_factory_(this),
- callback_(callback) {
+ : callback_(callback), weak_factory_(this) {
DCHECK(!callback.is_null());
InitializeForwarder();
}
@@ -113,17 +112,15 @@
weak_factory_.GetWeakPtr());
}
- // Used to ensure Forward() is not run when this object is destroyed.
- // TODO(ckehoe): This should be the last class member.
- // Move it there when crbug.com/433583 is fixed.
- base::WeakPtrFactory<CancelableCallback<void(A...)> > weak_factory_;
-
// The wrapper closure.
base::Callback<void(A...)> forwarder_;
// The stored closure that may be cancelled.
base::Callback<void(A...)> callback_;
+ // Used to ensure Forward() is not run when this object is destroyed.
+ base::WeakPtrFactory<CancelableCallback<void(A...)>> weak_factory_;
+
DISALLOW_COPY_AND_ASSIGN(CancelableCallback);
};
diff --git a/files/file_path.h b/files/file_path.h
index 6890866..67bbb4b 100644
--- a/files/file_path.h
+++ b/files/file_path.h
@@ -238,7 +238,7 @@
// ASSERT(new_path == path.value());
// NOTE: this is different from the original file_util implementation which
// returned the extension without a leading "." ("jpg" instead of ".jpg")
- StringType Extension() const;
+ StringType Extension() const WARN_UNUSED_RESULT;
// Returns the path's file extension, as in Extension(), but will
// never return a double extension.
@@ -247,7 +247,7 @@
// we can rename this to Extension() and the other to something like
// LongExtension(), defaulting to short extensions and leaving the
// long "extensions" to logic like base::GetUniquePathNumber().
- StringType FinalExtension() const;
+ StringType FinalExtension() const WARN_UNUSED_RESULT;
// Returns "C:\pics\jojo" for path "C:\pics\jojo.jpg"
// NOTE: this is slightly different from the similar file_util implementation
diff --git a/i18n/rtl.cc b/i18n/rtl.cc
index 392cb13..1cccae2 100644
--- a/i18n/rtl.cc
+++ b/i18n/rtl.cc
@@ -74,8 +74,8 @@
}
// Convert the ICU canonicalized locale to a string.
-std::string GetCanonicalLocale(const char* locale) {
- return GetLocaleString(icu::Locale::createCanonical(locale));
+std::string GetCanonicalLocale(const std::string& locale) {
+ return GetLocaleString(icu::Locale::createCanonical(locale.c_str()));
}
// Convert Chrome locale name to ICU locale name
diff --git a/i18n/rtl.h b/i18n/rtl.h
index aa5f681..9b9a0dc 100644
--- a/i18n/rtl.h
+++ b/i18n/rtl.h
@@ -40,7 +40,7 @@
BASE_I18N_EXPORT std::string GetConfiguredLocale();
// Canonicalize a string (eg. a POSIX locale string) to a Chrome locale name.
-BASE_I18N_EXPORT std::string GetCanonicalLocale(const char* locale);
+BASE_I18N_EXPORT std::string GetCanonicalLocale(const std::string& locale);
// Sets the default locale of ICU.
// Once the application locale of Chrome in GetApplicationLocale is determined,
diff --git a/ios/weak_nsobject.h b/ios/weak_nsobject.h
index 46aecb5..a1984bb 100644
--- a/ios/weak_nsobject.h
+++ b/ios/weak_nsobject.h
@@ -36,17 +36,28 @@
// NSObject, this relationship is maintained via the ObjectiveC associated
// object API, indirectly via an ObjectiveC CRBWeakNSProtocolSentinel class.
//
-// The implementation assumes that the tracked object will be released on the
-// same thread that the WeakNSObject is created on.
-//
+// Threading restrictions:
+// - Several WeakNSObject pointing to the same underlying object must all be
+// created and dereferenced on the same thread;
+// - thread safety is enforced by the implementation, except in two cases:
+// (1) it is allowed to copy a WeakNSObject on a different thread. However,
+// that copy must return to the original thread before being dereferenced,
+// (2) it is allowed to destroy a WeakNSObject on any thread;
+// - the implementation assumes that the tracked object will be released on the
+// same thread that the WeakNSObject is created on.
namespace base {
// WeakContainer keeps a weak pointer to an object and clears it when it
// receives nullify() from the object's sentinel.
class WeakContainer : public base::RefCountedThreadSafe<WeakContainer> {
public:
- WeakContainer(id object) : object_(object) {}
- id object() { return object_; }
+ explicit WeakContainer(id object) : object_(object) {}
+
+ id object() {
+ DCHECK(checker_.CalledOnValidThread());
+ return object_;
+ }
+
void nullify() {
DCHECK(checker_.CalledOnValidThread());
object_ = nil;
@@ -74,53 +85,63 @@
// Base class for all WeakNSObject derivatives.
template <typename NST>
-class WeakNSProtocol : public base::NonThreadSafe {
+class WeakNSProtocol {
public:
explicit WeakNSProtocol(NST object = nil) {
container_ = [CRBWeakNSProtocolSentinel containerForObject:object];
}
WeakNSProtocol(const WeakNSProtocol<NST>& that) {
+ // A WeakNSProtocol object can be copied on one thread and used on
+ // another.
+ checker_.DetachFromThread();
container_ = that.container_;
}
~WeakNSProtocol() {
- // A WeakNSProtocol object can be allocated on one thread and released on
+ // A WeakNSProtocol object can be used on one thread and released on
// another. This is not the case for the contained object.
- DetachFromThread();
+ checker_.DetachFromThread();
}
void reset(NST object = nil) {
- DCHECK(CalledOnValidThread());
+ DCHECK(checker_.CalledOnValidThread());
container_ = [CRBWeakNSProtocolSentinel containerForObject:object];
}
NST get() const {
- DCHECK(CalledOnValidThread());
+ DCHECK(checker_.CalledOnValidThread());
if (!container_.get())
return nil;
return container_->object();
}
WeakNSProtocol& operator=(const WeakNSProtocol<NST>& that) {
- DCHECK(CalledOnValidThread());
+ DCHECK(checker_.CalledOnValidThread());
container_ = that.container_;
return *this;
}
bool operator==(NST that) const {
- DCHECK(CalledOnValidThread());
+ DCHECK(checker_.CalledOnValidThread());
return get() == that;
}
- bool operator!=(NST that) const { return get() != that; }
+ bool operator!=(NST that) const {
+ DCHECK(checker_.CalledOnValidThread());
+ return get() != that;
+ }
- operator NST() const { return get(); }
+ operator NST() const {
+ DCHECK(checker_.CalledOnValidThread());
+ return get();
+ }
private:
// Refecounted reference to the container tracking the ObjectiveC object this
// class encapsulates.
scoped_refptr<base::WeakContainer> container_;
+ base::ThreadChecker checker_;
};
// Free functions
diff --git a/ios/weak_nsobject_unittest.mm b/ios/weak_nsobject_unittest.mm
index 9758aed..325dcd2 100644
--- a/ios/weak_nsobject_unittest.mm
+++ b/ios/weak_nsobject_unittest.mm
@@ -3,16 +3,19 @@
// found in the LICENSE file.
#include "base/basictypes.h"
+#include "base/bind.h"
#include "base/ios/weak_nsobject.h"
#include "base/mac/scoped_nsobject.h"
+#include "base/message_loop/message_loop.h"
+#include "base/single_thread_task_runner.h"
+#include "base/threading/thread.h"
#include "testing/gtest/include/gtest/gtest.h"
-using base::WeakNSObject;
-
+namespace base {
namespace {
TEST(WeakNSObjectTest, WeakNSObject) {
- base::scoped_nsobject<NSObject> p1([[NSObject alloc] init]);
+ scoped_nsobject<NSObject> p1([[NSObject alloc] init]);
WeakNSObject<NSObject> w1(p1);
EXPECT_TRUE(w1);
p1.reset();
@@ -20,7 +23,7 @@
}
TEST(WeakNSObjectTest, MultipleWeakNSObject) {
- base::scoped_nsobject<NSObject> p1([[NSObject alloc] init]);
+ scoped_nsobject<NSObject> p1([[NSObject alloc] init]);
WeakNSObject<NSObject> w1(p1);
WeakNSObject<NSObject> w2(w1);
EXPECT_TRUE(w1);
@@ -32,7 +35,7 @@
}
TEST(WeakNSObjectTest, WeakNSObjectDies) {
- base::scoped_nsobject<NSObject> p1([[NSObject alloc] init]);
+ scoped_nsobject<NSObject> p1([[NSObject alloc] init]);
{
WeakNSObject<NSObject> w1(p1);
EXPECT_TRUE(w1);
@@ -40,7 +43,7 @@
}
TEST(WeakNSObjectTest, WeakNSObjectReset) {
- base::scoped_nsobject<NSObject> p1([[NSObject alloc] init]);
+ scoped_nsobject<NSObject> p1([[NSObject alloc] init]);
WeakNSObject<NSObject> w1(p1);
EXPECT_TRUE(w1);
w1.reset();
@@ -50,8 +53,8 @@
}
TEST(WeakNSObjectTest, WeakNSObjectResetWithObject) {
- base::scoped_nsobject<NSObject> p1([[NSObject alloc] init]);
- base::scoped_nsobject<NSObject> p2([[NSObject alloc] init]);
+ scoped_nsobject<NSObject> p1([[NSObject alloc] init]);
+ scoped_nsobject<NSObject> p2([[NSObject alloc] init]);
WeakNSObject<NSObject> w1(p1);
EXPECT_TRUE(w1);
w1.reset(p2);
@@ -61,7 +64,7 @@
}
TEST(WeakNSObjectTest, WeakNSObjectEmpty) {
- base::scoped_nsobject<NSObject> p1([[NSObject alloc] init]);
+ scoped_nsobject<NSObject> p1([[NSObject alloc] init]);
WeakNSObject<NSObject> w1;
EXPECT_FALSE(w1);
w1.reset(p1);
@@ -71,7 +74,7 @@
}
TEST(WeakNSObjectTest, WeakNSObjectCopy) {
- base::scoped_nsobject<NSObject> p1([[NSObject alloc] init]);
+ scoped_nsobject<NSObject> p1([[NSObject alloc] init]);
WeakNSObject<NSObject> w1(p1);
WeakNSObject<NSObject> w2(w1);
EXPECT_TRUE(w1);
@@ -82,7 +85,7 @@
}
TEST(WeakNSObjectTest, WeakNSObjectAssignment) {
- base::scoped_nsobject<NSObject> p1([[NSObject alloc] init]);
+ scoped_nsobject<NSObject> p1([[NSObject alloc] init]);
WeakNSObject<NSObject> w1(p1);
WeakNSObject<NSObject> w2;
EXPECT_FALSE(w2);
@@ -94,4 +97,40 @@
EXPECT_FALSE(w2);
}
+// Touches |weak_data| by increasing its length by 1. Used to check that the
+// weak object can be dereferenced.
+void TouchWeakData(const WeakNSObject<NSMutableData>& weak_data) {
+ if (!weak_data)
+ return;
+ [weak_data increaseLengthBy:1];
+}
+
+// Makes a copy of |weak_object| on the current thread and posts a task to touch
+// the weak object on its original thread.
+void CopyWeakNSObjectAndPost(const WeakNSObject<NSMutableData>& weak_object,
+ scoped_refptr<SingleThreadTaskRunner> runner) {
+ WeakNSObject<NSMutableData> weak_copy(weak_object);
+ runner->PostTask(FROM_HERE, Bind(&TouchWeakData, weak_copy));
+}
+
+// Tests that the weak object can be copied on a different thread.
+TEST(WeakNSObjectTest, WeakNSObjectCopyOnOtherThread) {
+ MessageLoop loop;
+ Thread other_thread("WeakNSObjectCopyOnOtherThread");
+ other_thread.Start();
+
+ scoped_nsobject<NSMutableData> data([[NSMutableData alloc] init]);
+ WeakNSObject<NSMutableData> weak(data);
+
+ scoped_refptr<SingleThreadTaskRunner> runner = loop.task_runner();
+ other_thread.task_runner()->PostTask(
+ FROM_HERE, Bind(&CopyWeakNSObjectAndPost, weak, runner));
+ other_thread.Stop();
+ loop.RunUntilIdle();
+
+ // Check that TouchWeakData was called.
+ EXPECT_EQ(1u, [data length]);
+}
+
} // namespace
+} // namespace base
diff --git a/mac/cocoa_protocols.h b/mac/cocoa_protocols.h
index e10001f..ab34a19 100644
--- a/mac/cocoa_protocols.h
+++ b/mac/cocoa_protocols.h
@@ -7,10 +7,6 @@
#import <Cocoa/Cocoa.h>
-// GTM also maintains a list of empty protocols, but only the ones the library
-// requires. Augment that below.
-#import "third_party/google_toolbox_for_mac/src/GTMDefines.h"
-
// New Mac OS X SDKs introduce new protocols used for delegates. These
// protocol defintions aren't not present in earlier releases of the Mac OS X
// SDK. In order to support building against the new SDK, which requires
diff --git a/mac/scoped_nsobject.h b/mac/scoped_nsobject.h
index 8d7bd4a..8814b51 100644
--- a/mac/scoped_nsobject.h
+++ b/mac/scoped_nsobject.h
@@ -40,6 +40,11 @@
: object_([that.object_ retain]) {
}
+ template <typename NSU>
+ scoped_nsprotocol(const scoped_nsprotocol<NSU>& that)
+ : object_([that.get() retain]) {
+ }
+
~scoped_nsprotocol() {
[object_ release];
}
@@ -119,6 +124,11 @@
: scoped_nsprotocol<NST*>(that) {
}
+ template<typename NSU>
+ scoped_nsobject(const scoped_nsobject<NSU>& that)
+ : scoped_nsprotocol<NST*>(that) {
+ }
+
scoped_nsobject& operator=(const scoped_nsobject<NST>& that) {
scoped_nsprotocol<NST*>::operator=(that);
return *this;
@@ -135,6 +145,11 @@
: scoped_nsprotocol<id>(that) {
}
+ template<typename NSU>
+ scoped_nsobject(const scoped_nsobject<NSU>& that)
+ : scoped_nsprotocol<id>(that) {
+ }
+
scoped_nsobject& operator=(const scoped_nsobject<id>& that) {
scoped_nsprotocol<id>::operator=(that);
return *this;
diff --git a/mac/sdk_forward_declarations.h b/mac/sdk_forward_declarations.h
index f606dab..faa36ea 100644
--- a/mac/sdk_forward_declarations.h
+++ b/mac/sdk_forward_declarations.h
@@ -105,6 +105,7 @@
- (void)setAnimationBehavior:(NSWindowAnimationBehavior)newAnimationBehavior;
- (void)toggleFullScreen:(id)sender;
- (void)setRestorable:(BOOL)flag;
+- (NSRect)convertRectFromScreen:(NSRect)aRect;
@end
@interface NSCursor (LionSDKDeclarations)
diff --git a/memory/scoped_vector.h b/memory/scoped_vector.h
index 1b30f63..173ea5a 100644
--- a/memory/scoped_vector.h
+++ b/memory/scoped_vector.h
@@ -9,6 +9,7 @@
#include "base/basictypes.h"
#include "base/logging.h"
+#include "base/memory/scoped_ptr.h"
#include "base/move.h"
#include "base/stl_util.h"
@@ -64,6 +65,7 @@
reference back() { return v_.back(); }
void push_back(T* elem) { v_.push_back(elem); }
+ void push_back(scoped_ptr<T> elem) { v_.push_back(elem.release()); }
void pop_back() {
DCHECK(!empty());
diff --git a/memory/scoped_vector_unittest.cc b/memory/scoped_vector_unittest.cc
index b60ca14..220cfb0 100644
--- a/memory/scoped_vector_unittest.cc
+++ b/memory/scoped_vector_unittest.cc
@@ -308,4 +308,17 @@
EXPECT_EQ(LC_CONSTRUCTED, it->life_cycle_state());
}
+// Assertions for push_back(scoped_ptr).
+TEST(ScopedVectorTest, PushBackScopedPtr) {
+ int delete_counter = 0;
+ scoped_ptr<DeleteCounter> elem(new DeleteCounter(&delete_counter));
+ EXPECT_EQ(0, delete_counter);
+ {
+ ScopedVector<DeleteCounter> v;
+ v.push_back(elem.Pass());
+ EXPECT_EQ(0, delete_counter);
+ }
+ EXPECT_EQ(1, delete_counter);
+}
+
} // namespace
diff --git a/message_loop/message_pump_io_ios.h b/message_loop/message_pump_io_ios.h
index 18af4a8..317a59c 100644
--- a/message_loop/message_pump_io_ios.h
+++ b/message_loop/message_pump_io_ios.h
@@ -97,7 +97,7 @@
};
MessagePumpIOSForIO();
- virtual ~MessagePumpIOSForIO();
+ ~MessagePumpIOSForIO() override;
// Have the current thread's message loop watch for a a situation in which
// reading/writing to the FD can be performed without blocking.
diff --git a/message_loop/message_pump_io_ios_unittest.cc b/message_loop/message_pump_io_ios_unittest.cc
index 0bf8c08..ba96f83 100644
--- a/message_loop/message_pump_io_ios_unittest.cc
+++ b/message_loop/message_pump_io_ios_unittest.cc
@@ -18,9 +18,9 @@
MessagePumpIOSForIOTest()
: ui_loop_(MessageLoop::TYPE_UI),
io_thread_("MessagePumpIOSForIOTestIOThread") {}
- virtual ~MessagePumpIOSForIOTest() {}
+ ~MessagePumpIOSForIOTest() override {}
- virtual void SetUp() override {
+ void SetUp() override {
Thread::Options options(MessageLoop::TYPE_IO, 0);
ASSERT_TRUE(io_thread_.StartWithOptions(options));
ASSERT_EQ(MessageLoop::TYPE_IO, io_thread_.message_loop()->type());
@@ -30,7 +30,7 @@
ASSERT_EQ(0, ret);
}
- virtual void TearDown() override {
+ void TearDown() override {
if (IGNORE_EINTR(close(pipefds_[0])) < 0)
PLOG(ERROR) << "close";
if (IGNORE_EINTR(close(pipefds_[1])) < 0)
@@ -64,11 +64,11 @@
// nothing useful.
class StupidWatcher : public MessagePumpIOSForIO::Watcher {
public:
- virtual ~StupidWatcher() {}
+ ~StupidWatcher() override {}
// base:MessagePumpIOSForIO::Watcher interface
- virtual void OnFileCanReadWithoutBlocking(int fd) override {}
- virtual void OnFileCanWriteWithoutBlocking(int fd) override {}
+ void OnFileCanReadWithoutBlocking(int fd) override {}
+ void OnFileCanWriteWithoutBlocking(int fd) override {}
};
#if GTEST_HAS_DEATH_TEST && !defined(NDEBUG)
@@ -93,16 +93,12 @@
: controller_(controller) {
DCHECK(controller_);
}
- virtual ~BaseWatcher() {}
+ ~BaseWatcher() override {}
// MessagePumpIOSForIO::Watcher interface
- virtual void OnFileCanReadWithoutBlocking(int /* fd */) override {
- NOTREACHED();
- }
+ void OnFileCanReadWithoutBlocking(int /* fd */) override { NOTREACHED(); }
- virtual void OnFileCanWriteWithoutBlocking(int /* fd */) override {
- NOTREACHED();
- }
+ void OnFileCanWriteWithoutBlocking(int /* fd */) override { NOTREACHED(); }
protected:
MessagePumpIOSForIO::FileDescriptorWatcher* controller_;
@@ -114,11 +110,9 @@
MessagePumpIOSForIO::FileDescriptorWatcher* controller)
: BaseWatcher(controller) {}
- virtual ~DeleteWatcher() {
- DCHECK(!controller_);
- }
+ ~DeleteWatcher() override { DCHECK(!controller_); }
- virtual void OnFileCanWriteWithoutBlocking(int /* fd */) override {
+ void OnFileCanWriteWithoutBlocking(int /* fd */) override {
DCHECK(controller_);
delete controller_;
controller_ = NULL;
@@ -146,9 +140,9 @@
pump_(pump),
fd_to_start_watching_(fd_to_start_watching) {}
- virtual ~StopWatcher() {}
+ ~StopWatcher() override {}
- virtual void OnFileCanWriteWithoutBlocking(int /* fd */) override {
+ void OnFileCanWriteWithoutBlocking(int /* fd */) override {
controller_->StopWatchingFileDescriptor();
if (fd_to_start_watching_ >= 0) {
pump_->WatchFileDescriptor(fd_to_start_watching_,
diff --git a/message_loop/message_pump_mac.h b/message_loop/message_pump_mac.h
index 55ab2c6..c853202 100644
--- a/message_loop/message_pump_mac.h
+++ b/message_loop/message_pump_mac.h
@@ -263,9 +263,9 @@
class MessagePumpUIApplication : public MessagePumpCFRunLoopBase {
public:
MessagePumpUIApplication();
- virtual ~MessagePumpUIApplication();
- virtual void DoRun(Delegate* delegate) override;
- virtual void Quit() override;
+ ~MessagePumpUIApplication() override;
+ void DoRun(Delegate* delegate) override;
+ void Quit() override;
// This message pump can not spin the main message loop directly. Instead,
// call |Attach()| to set up a delegate. It is an error to call |Run()|.
diff --git a/message_loop/message_pump_win.cc b/message_loop/message_pump_win.cc
index c140691..a7a1485 100644
--- a/message_loop/message_pump_win.cc
+++ b/message_loop/message_pump_win.cc
@@ -162,6 +162,11 @@
// static
LRESULT CALLBACK MessagePumpForUI::WndProcThunk(
HWND hwnd, UINT message, WPARAM wparam, LPARAM lparam) {
+ // TODO(vadimt): Remove ScopedTracker below once crbug.com/440919 is fixed.
+ tracked_objects::ScopedTracker tracking_profile(
+ FROM_HERE_WITH_EXPLICIT_FUNCTION(
+ "440919 MessagePumpForUI::WndProcThunk"));
+
switch (message) {
case kMsgHaveWork:
reinterpret_cast<MessagePumpForUI*>(wparam)->HandleWorkMessage();
diff --git a/metrics/field_trial.cc b/metrics/field_trial.cc
index 7efca7a..e03c94c 100644
--- a/metrics/field_trial.cc
+++ b/metrics/field_trial.cc
@@ -223,6 +223,20 @@
return true;
}
+bool FieldTrial::GetState(FieldTrialState* field_trial_state) const {
+ if (!enable_field_trial_)
+ return false;
+ field_trial_state->trial_name = trial_name_;
+ // If the group name is empty (hasn't been finalized yet), use the default
+ // group name instead.
+ if (!group_name_.empty())
+ field_trial_state->group_name = group_name_;
+ else
+ field_trial_state->group_name = default_group_name_;
+ field_trial_state->activated = group_reported_;
+ return true;
+}
+
//------------------------------------------------------------------------------
// FieldTrialList methods and members.
@@ -387,6 +401,29 @@
}
// static
+void FieldTrialList::AllStatesToString(std::string* output) {
+ if (!global_)
+ return;
+ AutoLock auto_lock(global_->lock_);
+
+ for (const auto& registered : global_->registered_) {
+ FieldTrial::FieldTrialState trial;
+ if (!registered.second->GetState(&trial))
+ continue;
+ DCHECK_EQ(std::string::npos,
+ trial.trial_name.find(kPersistentStringSeparator));
+ DCHECK_EQ(std::string::npos,
+ trial.group_name.find(kPersistentStringSeparator));
+ if (trial.activated)
+ output->append(1, kActivationMarker);
+ output->append(trial.trial_name);
+ output->append(1, kPersistentStringSeparator);
+ output->append(trial.group_name);
+ output->append(1, kPersistentStringSeparator);
+ }
+}
+
+// static
void FieldTrialList::GetActiveFieldTrialGroups(
FieldTrial::ActiveGroups* active_groups) {
DCHECK(active_groups->empty());
diff --git a/metrics/field_trial.h b/metrics/field_trial.h
index e2e5439..26257ab 100644
--- a/metrics/field_trial.h
+++ b/metrics/field_trial.h
@@ -106,6 +106,14 @@
std::string group_name;
};
+ // A triplet representing a FieldTrial, its selected group and whether it's
+ // active.
+ struct FieldTrialState {
+ std::string trial_name;
+ std::string group_name;
+ bool activated;
+ };
+
typedef std::vector<ActiveGroup> ActiveGroups;
// A return value to indicate that a given instance has not yet had a group
@@ -180,8 +188,10 @@
FRIEND_TEST_ALL_PREFIXES(FieldTrialTest, OneWinner);
FRIEND_TEST_ALL_PREFIXES(FieldTrialTest, DisableProbability);
FRIEND_TEST_ALL_PREFIXES(FieldTrialTest, ActiveGroups);
+ FRIEND_TEST_ALL_PREFIXES(FieldTrialTest, AllGroups);
FRIEND_TEST_ALL_PREFIXES(FieldTrialTest, ActiveGroupsNotFinalized);
FRIEND_TEST_ALL_PREFIXES(FieldTrialTest, Save);
+ FRIEND_TEST_ALL_PREFIXES(FieldTrialTest, SaveAll);
FRIEND_TEST_ALL_PREFIXES(FieldTrialTest, DuplicateRestore);
FRIEND_TEST_ALL_PREFIXES(FieldTrialTest, SetForcedTurnFeatureOff);
FRIEND_TEST_ALL_PREFIXES(FieldTrialTest, SetForcedTurnFeatureOn);
@@ -230,6 +240,13 @@
// untouched.
bool GetActiveGroup(ActiveGroup* active_group) const;
+ // Returns the trial name and selected group name for this field trial via
+ // the output parameter |field_trial_state|, but only if the trial has not
+ // been disabled. In that case, true is returned and |field_trial_state| is
+ // filled in; otherwise, the result is false and |field_trial_state| is left
+ // untouched.
+ bool GetState(FieldTrialState* field_trial_state) const;
+
// Returns the group_name. A winner need not have been chosen.
std::string group_name_internal() const { return group_name_; }
@@ -404,6 +421,16 @@
// by |CreateTrialsFromString()|.
static void StatesToString(std::string* output);
+ // Creates a persistent representation of all FieldTrial instances for
+ // resurrection in another process. This allows randomization to be done in
+ // one process, and secondary processes can be synchronized on the result.
+ // The resulting string contains the name and group name pairs of all
+ // registered FieldTrials which have not been disabled, with "/" used
+ // to separate all names and to terminate the string. All activated trials
+ // have their name prefixed with "*". This string is parsed by
+ // |CreateTrialsFromString()|.
+ static void AllStatesToString(std::string* output);
+
// Fills in the supplied vector |active_groups| (which must be empty when
// called) with a snapshot of all registered FieldTrials for which the group
// has been chosen and externally observed (via |group()|) and which have
diff --git a/metrics/field_trial_unittest.cc b/metrics/field_trial_unittest.cc
index ce95c2a..f1a1042 100644
--- a/metrics/field_trial_unittest.cc
+++ b/metrics/field_trial_unittest.cc
@@ -311,6 +311,36 @@
}
}
+TEST_F(FieldTrialTest, AllGroups) {
+ FieldTrial::FieldTrialState field_trial_state;
+ std::string one_winner("One Winner");
+ scoped_refptr<FieldTrial> trial =
+ CreateFieldTrial(one_winner, 10, "Default", NULL);
+ std::string winner("Winner");
+ trial->AppendGroup(winner, 10);
+ EXPECT_TRUE(trial->GetState(&field_trial_state));
+ EXPECT_EQ(one_winner, field_trial_state.trial_name);
+ EXPECT_EQ(winner, field_trial_state.group_name);
+ trial->group();
+ EXPECT_TRUE(trial->GetState(&field_trial_state));
+ EXPECT_EQ(one_winner, field_trial_state.trial_name);
+ EXPECT_EQ(winner, field_trial_state.group_name);
+
+ std::string multi_group("MultiGroup");
+ scoped_refptr<FieldTrial> multi_group_trial =
+ CreateFieldTrial(multi_group, 9, "Default", NULL);
+
+ multi_group_trial->AppendGroup("Me", 3);
+ multi_group_trial->AppendGroup("You", 3);
+ multi_group_trial->AppendGroup("Them", 3);
+ EXPECT_TRUE(multi_group_trial->GetState(&field_trial_state));
+ // Finalize the group selection by accessing the selected group.
+ multi_group_trial->group();
+ EXPECT_TRUE(multi_group_trial->GetState(&field_trial_state));
+ EXPECT_EQ(multi_group, field_trial_state.trial_name);
+ EXPECT_EQ(multi_group_trial->group_name(), field_trial_state.group_name);
+}
+
TEST_F(FieldTrialTest, ActiveGroupsNotFinalized) {
const char kTrialName[] = "TestTrial";
const char kSecondaryGroupName[] = "SecondaryGroup";
@@ -388,6 +418,44 @@
EXPECT_EQ("Some name/Winner/xxx/yyyy/zzz/default/", save_string);
}
+TEST_F(FieldTrialTest, SaveAll) {
+ std::string save_string;
+
+ scoped_refptr<FieldTrial> trial =
+ CreateFieldTrial("Some name", 10, "Default some name", NULL);
+ EXPECT_EQ("", trial->group_name_internal());
+ FieldTrialList::AllStatesToString(&save_string);
+ EXPECT_EQ("Some name/Default some name/", save_string);
+ save_string.clear();
+
+ // Create a winning group.
+ trial->AppendGroup("Winner", 10);
+ // Finalize the group selection by accessing the selected group.
+ trial->group();
+ FieldTrialList::AllStatesToString(&save_string);
+ EXPECT_EQ("*Some name/Winner/", save_string);
+ save_string.clear();
+
+ // Create a second trial and winning group.
+ scoped_refptr<FieldTrial> trial2 =
+ CreateFieldTrial("xxx", 10, "Default xxx", NULL);
+ trial2->AppendGroup("yyyy", 10);
+ // Finalize the group selection by accessing the selected group.
+ trial2->group();
+
+ FieldTrialList::AllStatesToString(&save_string);
+ // We assume names are alphabetized... though this is not critical.
+ EXPECT_EQ("*Some name/Winner/*xxx/yyyy/", save_string);
+ save_string.clear();
+
+ // Create a third trial with only the default group.
+ scoped_refptr<FieldTrial> trial3 =
+ CreateFieldTrial("zzz", 10, "default", NULL);
+
+ FieldTrialList::AllStatesToString(&save_string);
+ EXPECT_EQ("*Some name/Winner/*xxx/yyyy/zzz/default/", save_string);
+}
+
TEST_F(FieldTrialTest, Restore) {
ASSERT_FALSE(FieldTrialList::TrialExists("Some_name"));
ASSERT_FALSE(FieldTrialList::TrialExists("xxx"));
@@ -1014,6 +1082,43 @@
}
}
+TEST(FieldTrialTestWithoutList, StatesStringFormat) {
+ std::string save_string;
+
+ // Scoping the first FieldTrialList, as we need another one to test the
+ // importing function.
+ {
+ FieldTrialList field_trial_list(NULL);
+ scoped_refptr<FieldTrial> trial =
+ CreateFieldTrial("Abc", 10, "Default some name", NULL);
+ trial->AppendGroup("cba", 10);
+ trial->group();
+ scoped_refptr<FieldTrial> trial2 =
+ CreateFieldTrial("Xyz", 10, "Default xxx", NULL);
+ trial2->AppendGroup("zyx", 10);
+ trial2->group();
+ scoped_refptr<FieldTrial> trial3 =
+ CreateFieldTrial("zzz", 10, "default", NULL);
+
+ FieldTrialList::AllStatesToString(&save_string);
+ }
+
+ // Starting with a new blank FieldTrialList.
+ FieldTrialList field_trial_list(NULL);
+ ASSERT_TRUE(field_trial_list.CreateTrialsFromString(
+ save_string, FieldTrialList::DONT_ACTIVATE_TRIALS,
+ std::set<std::string>()));
+
+ FieldTrial::ActiveGroups active_groups;
+ field_trial_list.GetActiveFieldTrialGroups(&active_groups);
+ ASSERT_EQ(2U, active_groups.size());
+ EXPECT_EQ("Abc", active_groups[0].trial_name);
+ EXPECT_EQ("cba", active_groups[0].group_name);
+ EXPECT_EQ("Xyz", active_groups[1].trial_name);
+ EXPECT_EQ("zyx", active_groups[1].group_name);
+ EXPECT_TRUE(field_trial_list.TrialExists("zzz"));
+}
+
#if GTEST_HAS_DEATH_TEST
TEST(FieldTrialDeathTest, OneTimeRandomizedTrialWithoutFieldTrialList) {
// Trying to instantiate a one-time randomized field trial before the
diff --git a/power_monitor/power_monitor_device_source_win.cc b/power_monitor/power_monitor_device_source_win.cc
index b8b16e1..0e199dc 100644
--- a/power_monitor/power_monitor_device_source_win.cc
+++ b/power_monitor/power_monitor_device_source_win.cc
@@ -5,6 +5,7 @@
#include "base/power_monitor/power_monitor.h"
#include "base/power_monitor/power_monitor_device_source.h"
#include "base/power_monitor/power_monitor_source.h"
+#include "base/profiler/scoped_tracker.h"
#include "base/win/wrapped_window_proc.h"
namespace base {
@@ -98,6 +99,11 @@
UINT message,
WPARAM wparam,
LPARAM lparam) {
+ // TODO(vadimt): Remove ScopedTracker below once crbug.com/440919 is fixed.
+ tracked_objects::ScopedTracker tracking_profile(
+ FROM_HERE_WITH_EXPLICIT_FUNCTION(
+ "440919 PowerMonitorDeviceSource::PowerMessageWindow::WndProcThunk"));
+
switch (message) {
case WM_POWERBROADCAST:
ProcessWmPowerBroadcastMessage(wparam);
diff --git a/process/kill.h b/process/kill.h
index f697701..e8ce334 100644
--- a/process/kill.h
+++ b/process/kill.h
@@ -154,8 +154,8 @@
#if defined(OS_POSIX) && !defined(OS_MACOSX)
// The nicer version of EnsureProcessTerminated() that is patient and will
-// wait for |process_handle| to finish and then reap it.
-BASE_EXPORT void EnsureProcessGetsReaped(ProcessHandle process_handle);
+// wait for |pid| to finish and then reap it.
+BASE_EXPORT void EnsureProcessGetsReaped(ProcessId pid);
#endif
} // namespace base
diff --git a/process/kill_posix.cc b/process/kill_posix.cc
index 3f304ca..9e9b5fb 100644
--- a/process/kill_posix.cc
+++ b/process/kill_posix.cc
@@ -473,12 +473,12 @@
PlatformThread::CreateNonJoinable(0, reaper);
}
-void EnsureProcessGetsReaped(ProcessHandle process) {
+void EnsureProcessGetsReaped(ProcessId pid) {
// If the child is already dead, then there's nothing to do.
- if (IsChildDead(process))
+ if (IsChildDead(pid))
return;
- BackgroundReaper* reaper = new BackgroundReaper(process, 0);
+ BackgroundReaper* reaper = new BackgroundReaper(pid, 0);
PlatformThread::CreateNonJoinable(0, reaper);
}
diff --git a/process/launch.cc b/process/launch.cc
index a1c4d21..1c752bd 100644
--- a/process/launch.cc
+++ b/process/launch.cc
@@ -28,6 +28,9 @@
, clone_flags(0)
, allow_new_privs(false)
#endif // OS_LINUX
+#if defined(OS_POSIX)
+ , pre_exec_delegate(NULL)
+#endif // OS_POSIX
#if defined(OS_CHROMEOS)
, ctrl_terminal_fd(-1)
#endif // OS_CHROMEOS
diff --git a/process/launch.h b/process/launch.h
index 6cd02d6..eca4f8f 100644
--- a/process/launch.h
+++ b/process/launch.h
@@ -37,6 +37,24 @@
// Options for launching a subprocess that are passed to LaunchProcess().
// The default constructor constructs the object with default options.
struct BASE_EXPORT LaunchOptions {
+#if defined(OS_POSIX)
+ // Delegate to be run in between fork and exec in the subprocess (see
+ // pre_exec_delegate below)
+ class BASE_EXPORT PreExecDelegate {
+ public:
+ PreExecDelegate() {}
+ virtual ~PreExecDelegate() {}
+
+ // Since this is to be run between fork and exec, and fork may have happened
+ // while multiple threads were running, this function needs to be async
+ // safe.
+ virtual void RunAsyncSafe() = 0;
+
+ private:
+ DISALLOW_COPY_AND_ASSIGN(PreExecDelegate);
+ };
+#endif // defined(OS_POSIX)
+
LaunchOptions();
~LaunchOptions();
@@ -115,6 +133,9 @@
#if defined(OS_LINUX)
// If non-zero, start the process using clone(), using flags as provided.
+ // Unlike in clone, clone_flags may not contain a custom termination signal
+ // that is sent to the parent when the child dies. The termination signal will
+ // always be set to SIGCHLD.
int clone_flags;
// By default, child processes will have the PR_SET_NO_NEW_PRIVS bit set. If
@@ -122,6 +143,16 @@
bool allow_new_privs;
#endif // defined(OS_LINUX)
+#if defined(OS_POSIX)
+ // If non-null, a delegate to be run immediately prior to executing the new
+ // program in the child process.
+ //
+ // WARNING: If LaunchProcess is called in the presence of multiple threads,
+ // code running in this delegate essentially needs to be async-signal safe
+ // (see man 7 signal for a list of allowed functions).
+ PreExecDelegate* pre_exec_delegate;
+#endif // defined(OS_POSIX)
+
#if defined(OS_CHROMEOS)
// If non-negative, the specified file descriptor will be set as the launched
// process' controlling terminal.
@@ -156,12 +187,6 @@
BASE_EXPORT Process LaunchProcess(const CommandLine& cmdline,
const LaunchOptions& options);
-// Deprecated version.
-// TODO(rvargas) crbug.com/417532: Remove this after migrating all consumers.
-BASE_EXPORT bool LaunchProcess(const CommandLine& cmdline,
- const LaunchOptions& options,
- ProcessHandle* process_handle);
-
#if defined(OS_WIN)
// Windows-specific LaunchProcess that takes the command line as a
// string. Useful for situations where you need to control the
@@ -192,12 +217,6 @@
BASE_EXPORT Process LaunchProcess(const std::vector<std::string>& argv,
const LaunchOptions& options);
-// Deprecated version.
-// TODO(rvargas) crbug.com/417532: Remove this after migrating all consumers.
-BASE_EXPORT bool LaunchProcess(const std::vector<std::string>& argv,
- const LaunchOptions& options,
- ProcessHandle* process_handle);
-
// Close all file descriptors, except those which are a destination in the
// given multimap. Only call this function in a child process where you know
// that there aren't any other threads.
diff --git a/process/launch_posix.cc b/process/launch_posix.cc
index c60cfdc..6c9ed3f 100644
--- a/process/launch_posix.cc
+++ b/process/launch_posix.cc
@@ -277,9 +277,13 @@
}
}
-bool LaunchProcess(const std::vector<std::string>& argv,
- const LaunchOptions& options,
- ProcessHandle* process_handle) {
+Process LaunchProcess(const CommandLine& cmdline,
+ const LaunchOptions& options) {
+ return LaunchProcess(cmdline.argv(), options);
+}
+
+Process LaunchProcess(const std::vector<std::string>& argv,
+ const LaunchOptions& options) {
size_t fd_shuffle_size = 0;
if (options.fds_to_remap) {
fd_shuffle_size = options.fds_to_remap->size();
@@ -311,7 +315,17 @@
// and that signal handling follows the process-creation rules.
RAW_CHECK(
!(options.clone_flags & (CLONE_SIGHAND | CLONE_THREAD | CLONE_VM)));
- pid = syscall(__NR_clone, options.clone_flags, 0, 0, 0);
+
+ // We specify a null ptid and ctid.
+ RAW_CHECK(
+ !(options.clone_flags &
+ (CLONE_CHILD_CLEARTID | CLONE_CHILD_SETTID | CLONE_PARENT_SETTID)));
+
+ // Since we use waitpid, we do not support custom termination signals in the
+ // clone flags.
+ RAW_CHECK((options.clone_flags & 0xff) == 0);
+
+ pid = ForkWithFlags(options.clone_flags | SIGCHLD, nullptr, nullptr);
} else
#endif
{
@@ -325,7 +339,7 @@
if (pid < 0) {
DPLOG(ERROR) << "fork";
- return false;
+ return Process();
} else if (pid == 0) {
// Child process
@@ -448,6 +462,12 @@
}
#endif
+#if defined(OS_POSIX)
+ if (options.pre_exec_delegate != nullptr) {
+ options.pre_exec_delegate->RunAsyncSafe();
+ }
+#endif
+
for (size_t i = 0; i < argv.size(); i++)
argv_cstr[i] = const_cast<char*>(argv[i].c_str());
argv_cstr[argv.size()] = NULL;
@@ -465,37 +485,9 @@
pid_t ret = HANDLE_EINTR(waitpid(pid, 0, 0));
DPCHECK(ret > 0);
}
-
- if (process_handle)
- *process_handle = pid;
}
- return true;
-}
-
-Process LaunchProcess(const std::vector<std::string>& argv,
- const LaunchOptions& options) {
- ProcessHandle process_handle;
- if (LaunchProcess(argv, options, &process_handle))
- return Process(process_handle);
-
- return Process();
-}
-
-
-bool LaunchProcess(const CommandLine& cmdline,
- const LaunchOptions& options,
- ProcessHandle* process_handle) {
- return LaunchProcess(cmdline.argv(), options, process_handle);
-}
-
-Process LaunchProcess(const CommandLine& cmdline,
- const LaunchOptions& options) {
- ProcessHandle process_handle;
- if (LaunchProcess(cmdline, options, &process_handle))
- return Process(process_handle);
-
- return Process();
+ return Process(pid);
}
void RaiseProcessToHighPriority() {
diff --git a/process/launch_win.cc b/process/launch_win.cc
index 1d83ef9..c2bd295 100644
--- a/process/launch_win.cc
+++ b/process/launch_win.cc
@@ -105,9 +105,13 @@
std::ios::sync_with_stdio();
}
-bool LaunchProcess(const string16& cmdline,
- const LaunchOptions& options,
- win::ScopedHandle* process_handle) {
+Process LaunchProcess(const CommandLine& cmdline,
+ const LaunchOptions& options) {
+ return LaunchProcess(cmdline.GetCommandLineString(), options);
+}
+
+Process LaunchProcess(const string16& cmdline,
+ const LaunchOptions& options) {
win::StartupInformation startup_info_wrapper;
STARTUPINFO* startup_info = startup_info_wrapper.startup_info();
@@ -119,18 +123,18 @@
} else {
if (base::win::GetVersion() < base::win::VERSION_VISTA) {
DLOG(ERROR) << "Specifying handles to inherit requires Vista or later.";
- return false;
+ return Process();
}
if (options.handles_to_inherit->size() >
std::numeric_limits<DWORD>::max() / sizeof(HANDLE)) {
DLOG(ERROR) << "Too many handles to inherit.";
- return false;
+ return Process();
}
if (!startup_info_wrapper.InitializeProcThreadAttributeList(1)) {
DPLOG(ERROR);
- return false;
+ return Process();
}
if (!startup_info_wrapper.UpdateProcThreadAttribute(
@@ -139,7 +143,7 @@
static_cast<DWORD>(options.handles_to_inherit->size() *
sizeof(HANDLE)))) {
DPLOG(ERROR);
- return false;
+ return Process();
}
inherit_handles = true;
@@ -184,7 +188,7 @@
if (!CreateEnvironmentBlock(&enviroment_block, options.as_user, FALSE)) {
DPLOG(ERROR);
- return false;
+ return Process();
}
BOOL launched =
@@ -197,7 +201,7 @@
if (!launched) {
DPLOG(ERROR) << "Command line:" << std::endl << UTF16ToUTF8(cmdline)
<< std::endl;;
- return false;
+ return Process();
}
} else {
if (!CreateProcess(NULL,
@@ -206,7 +210,7 @@
startup_info, &temp_process_info)) {
DPLOG(ERROR) << "Command line:" << std::endl << UTF16ToUTF8(cmdline)
<< std::endl;;
- return false;
+ return Process();
}
}
base::win::ScopedProcessInformation process_info(temp_process_info);
@@ -216,7 +220,7 @@
process_info.process_handle())) {
DLOG(ERROR) << "Could not AssignProcessToObject.";
KillProcess(process_info.process_handle(), kProcessKilledExitCode, true);
- return false;
+ return Process();
}
ResumeThread(process_info.thread_handle());
@@ -225,43 +229,7 @@
if (options.wait)
WaitForSingleObject(process_info.process_handle(), INFINITE);
- // If the caller wants the process handle, we won't close it.
- if (process_handle)
- process_handle->Set(process_info.TakeProcessHandle());
-
- return true;
-}
-
-// TODO(rvargas) crbug.com/416721: Remove this stub after LaunchProcess is
-// fully migrated to use Process.
-Process LaunchProcess(const string16& cmdline,
- const LaunchOptions& options) {
- win::ScopedHandle process_handle;
- if (LaunchProcess(cmdline, options, &process_handle))
- return Process(process_handle.Take());
-
- return Process();
-}
-
-bool LaunchProcess(const CommandLine& cmdline,
- const LaunchOptions& options,
- ProcessHandle* process_handle) {
- if (!process_handle)
- return LaunchProcess(cmdline.GetCommandLineString(), options, NULL);
-
- win::ScopedHandle process;
- bool rv = LaunchProcess(cmdline.GetCommandLineString(), options, &process);
- *process_handle = process.Take();
- return rv;
-}
-
-Process LaunchProcess(const CommandLine& cmdline,
- const LaunchOptions& options) {
- ProcessHandle process_handle;
- if (LaunchProcess(cmdline, options, &process_handle))
- return Process(process_handle);
-
- return Process();
+ return Process(process_info.TakeProcessHandle());
}
Process LaunchElevatedProcess(const CommandLine& cmdline,
diff --git a/process/process.h b/process/process.h
index ad8f8ee..b0fd8d9 100644
--- a/process/process.h
+++ b/process/process.h
@@ -49,6 +49,11 @@
// Returns an object for the current process.
static Process Current();
+ // Returns a Process for the given |pid|. On Windows the handle is opened
+ // with more access rights and must only be used by trusted code (can read the
+ // address space and duplicate handles).
+ static Process OpenWithExtraPriviles(ProcessId pid);
+
// Creates an object from a |handle| owned by someone else.
// Don't use this for new code. It is only intended to ease the migration to
// a strict ownership model.
@@ -112,6 +117,25 @@
#endif
};
+#if defined(OS_LINUX)
+// A wrapper for clone with fork-like behavior, meaning that it returns the
+// child's pid in the parent and 0 in the child. |flags|, |ptid|, and |ctid| are
+// as in the clone system call (the CLONE_VM flag is not supported).
+//
+// This function uses the libc clone wrapper (which updates libc's pid cache)
+// internally, so callers may expect things like getpid() to work correctly
+// after in both the child and parent. An exception is when this code is run
+// under Valgrind. Valgrind does not support the libc clone wrapper, so the libc
+// pid cache may be incorrect after this function is called under Valgrind.
+//
+// As with fork(), callers should be extremely careful when calling this while
+// multiple threads are running, since at the time the fork happened, the
+// threads could have been in any state (potentially holding locks, etc.).
+// Callers should most likely call execve() in the child soon after calling
+// this.
+BASE_EXPORT pid_t ForkWithFlags(unsigned long flags, pid_t* ptid, pid_t* ctid);
+#endif
+
} // namespace base
#endif // BASE_PROCESS_PROCESS_PROCESS_H_
diff --git a/process/process_handle.h b/process/process_handle.h
index 6f8094e..368f952 100644
--- a/process/process_handle.h
+++ b/process/process_handle.h
@@ -44,15 +44,6 @@
// CloseProcessHandle when you are done with it. Returns true on success.
BASE_EXPORT bool OpenProcessHandle(ProcessId pid, ProcessHandle* handle);
-// Converts a PID to a process handle. On Windows the handle is opened
-// with more access rights and must only be used by trusted code.
-// You have to close returned handle using CloseProcessHandle. Returns true
-// on success.
-// TODO(sanjeevr): Replace all calls to OpenPrivilegedProcessHandle with the
-// more specific OpenProcessHandleWithAccess method and delete this.
-BASE_EXPORT bool OpenPrivilegedProcessHandle(ProcessId pid,
- ProcessHandle* handle);
-
// Converts a PID to a process handle using the desired access flags. Use a
// combination of the kProcessAccess* flags defined above for |access_flags|.
BASE_EXPORT bool OpenProcessHandleWithAccess(ProcessId pid,
diff --git a/process/process_handle_posix.cc b/process/process_handle_posix.cc
index 4013254..94b2c2f 100644
--- a/process/process_handle_posix.cc
+++ b/process/process_handle_posix.cc
@@ -23,12 +23,6 @@
return true;
}
-bool OpenPrivilegedProcessHandle(ProcessId pid, ProcessHandle* handle) {
- // On POSIX permissions are checked for each operation on process,
- // not when opening a "handle".
- return OpenProcessHandle(pid, handle);
-}
-
bool OpenProcessHandleWithAccess(ProcessId pid,
uint32 access_flags,
ProcessHandle* handle) {
diff --git a/process/process_handle_win.cc b/process/process_handle_win.cc
index 3bc3a12..595d5b0 100644
--- a/process/process_handle_win.cc
+++ b/process/process_handle_win.cc
@@ -36,21 +36,6 @@
return true;
}
-bool OpenPrivilegedProcessHandle(ProcessId pid, ProcessHandle* handle) {
- ProcessHandle result = OpenProcess(PROCESS_DUP_HANDLE |
- PROCESS_TERMINATE |
- PROCESS_QUERY_INFORMATION |
- PROCESS_VM_READ |
- SYNCHRONIZE,
- FALSE, pid);
-
- if (result == NULL)
- return false;
-
- *handle = result;
- return true;
-}
-
bool OpenProcessHandleWithAccess(ProcessId pid,
uint32 access_flags,
ProcessHandle* handle) {
diff --git a/process/process_linux.cc b/process/process_linux.cc
index 59ee288..cfa3ed5 100644
--- a/process/process_linux.cc
+++ b/process/process_linux.cc
@@ -5,14 +5,21 @@
#include "base/process/process.h"
#include <errno.h>
+#include <pthread.h>
+#include <sched.h>
+#include <setjmp.h>
#include <sys/resource.h>
+#include <sys/syscall.h>
+#include "base/compiler_specific.h"
#include "base/files/file_util.h"
#include "base/lazy_instance.h"
#include "base/logging.h"
#include "base/strings/string_split.h"
#include "base/strings/stringprintf.h"
#include "base/synchronization/lock.h"
+#include "base/third_party/valgrind/valgrind.h"
+#include "build/build_config.h"
namespace base {
@@ -78,6 +85,52 @@
bool can_reraise_priority;
};
+bool IsRunningOnValgrind() {
+ return RUNNING_ON_VALGRIND;
+}
+
+// This function runs on the stack specified on the clone call. It uses longjmp
+// to switch back to the original stack so the child can return from sys_clone.
+int CloneHelper(void* arg) {
+ jmp_buf* env_ptr = reinterpret_cast<jmp_buf*>(arg);
+ longjmp(*env_ptr, 1);
+
+ // Should not be reached.
+ RAW_CHECK(false);
+ return 1;
+}
+
+// This function is noinline to ensure that stack_buf is below the stack pointer
+// that is saved when setjmp is called below. This is needed because when
+// compiled with FORTIFY_SOURCE, glibc's longjmp checks that the stack is moved
+// upwards. See crbug.com/442912 for more details.
+#if defined(ADDRESS_SANITIZER)
+// Disable AddressSanitizer instrumentation for this function to make sure
+// |stack_buf| is allocated on thread stack instead of ASan's fake stack.
+// Under ASan longjmp() will attempt to clean up the area between the old and
+// new stack pointers and print a warning that may confuse the user.
+__attribute__((no_sanitize_address))
+#endif
+NOINLINE pid_t CloneAndLongjmpInChild(unsigned long flags,
+ pid_t* ptid,
+ pid_t* ctid,
+ jmp_buf* env) {
+ // We use the libc clone wrapper instead of making the syscall
+ // directly because making the syscall may fail to update the libc's
+ // internal pid cache. The libc interface unfortunately requires
+ // specifying a new stack, so we use setjmp/longjmp to emulate
+ // fork-like behavior.
+ char stack_buf[PTHREAD_STACK_MIN];
+#if defined(ARCH_CPU_X86_FAMILY) || defined(ARCH_CPU_ARM_FAMILY) || \
+ defined(ARCH_CPU_MIPS64_FAMILY) || defined(ARCH_CPU_MIPS_FAMILY)
+ // The stack grows downward.
+ void* stack = stack_buf + sizeof(stack_buf);
+#else
+#error "Unsupported architecture"
+#endif
+ return clone(&CloneHelper, stack, flags, env, ptid, nullptr, ctid);
+}
+
} // namespace
// static
@@ -136,4 +189,43 @@
return result == 0;
}
+pid_t ForkWithFlags(unsigned long flags, pid_t* ptid, pid_t* ctid) {
+ const bool clone_tls_used = flags & CLONE_SETTLS;
+ const bool invalid_ctid =
+ (flags & (CLONE_CHILD_SETTID | CLONE_CHILD_CLEARTID)) && !ctid;
+ const bool invalid_ptid = (flags & CLONE_PARENT_SETTID) && !ptid;
+
+ // We do not support CLONE_VM.
+ const bool clone_vm_used = flags & CLONE_VM;
+
+ if (clone_tls_used || invalid_ctid || invalid_ptid || clone_vm_used) {
+ RAW_LOG(FATAL, "Invalid usage of ForkWithFlags");
+ }
+
+ // Valgrind's clone implementation does not support specifiying a child_stack
+ // without CLONE_VM, so we cannot use libc's clone wrapper when running under
+ // Valgrind. As a result, the libc pid cache may be incorrect under Valgrind.
+ // See crbug.com/442817 for more details.
+ if (IsRunningOnValgrind()) {
+ // See kernel/fork.c in Linux. There is different ordering of sys_clone
+ // parameters depending on CONFIG_CLONE_BACKWARDS* configuration options.
+#if defined(ARCH_CPU_X86_64)
+ return syscall(__NR_clone, flags, nullptr, ptid, ctid, nullptr);
+#elif defined(ARCH_CPU_X86) || defined(ARCH_CPU_ARM_FAMILY) || \
+ defined(ARCH_CPU_MIPS_FAMILY) || defined(ARCH_CPU_MIPS64_FAMILY)
+ // CONFIG_CLONE_BACKWARDS defined.
+ return syscall(__NR_clone, flags, nullptr, ptid, nullptr, ctid);
+#else
+#error "Unsupported architecture"
+#endif
+ }
+
+ jmp_buf env;
+ if (setjmp(env) == 0) {
+ return CloneAndLongjmpInChild(flags, ptid, ctid, &env);
+ }
+
+ return 0;
+}
+
} // namespace base
diff --git a/process/process_posix.cc b/process/process_posix.cc
index 58852bc..93dec98 100644
--- a/process/process_posix.cc
+++ b/process/process_posix.cc
@@ -38,6 +38,16 @@
}
// static
+Process Process::OpenWithExtraPriviles(ProcessId pid) {
+ if (pid == GetCurrentProcId())
+ return Current();
+
+ // On POSIX process handles are the same as PIDs, and there are no privileges
+ // to set.
+ return Process(pid);
+}
+
+// static
Process Process::DeprecatedGetProcessFromHandle(ProcessHandle handle) {
DCHECK_NE(handle, GetCurrentProcessHandle());
return Process(handle);
diff --git a/process/process_unittest.cc b/process/process_unittest.cc
index 5180f64..8130726 100644
--- a/process/process_unittest.cc
+++ b/process/process_unittest.cc
@@ -4,13 +4,27 @@
#include "base/process/process.h"
+#include "base/files/file_path.h"
+#include "base/files/file_util.h"
+#include "base/files/scoped_file.h"
+#include "base/posix/eintr_wrapper.h"
#include "base/process/kill.h"
#include "base/test/multiprocess_test.h"
#include "base/test/test_timeouts.h"
+#include "base/third_party/dynamic_annotations/dynamic_annotations.h"
#include "base/threading/platform_thread.h"
+#include "build/build_config.h"
#include "testing/gtest/include/gtest/gtest.h"
#include "testing/multiprocess_func_list.h"
+#if defined(OS_LINUX)
+#include <errno.h>
+#include <sched.h>
+#include <sys/syscall.h>
+#include <sys/types.h>
+#include <sys/wait.h>
+#include <unistd.h>
+#endif
namespace {
@@ -201,4 +215,105 @@
EXPECT_EQ(old_priority, new_priority);
}
+#if defined(OS_LINUX)
+const int kSuccess = 0;
+
+MULTIPROCESS_TEST_MAIN(CheckPidProcess) {
+ const pid_t kInitPid = 1;
+ const pid_t pid = syscall(__NR_getpid);
+ CHECK(pid == kInitPid);
+ CHECK(getpid() == pid);
+ return kSuccess;
+}
+
+TEST_F(ProcessTest, CloneFlags) {
+ if (RunningOnValgrind() || !PathExists(FilePath("/proc/self/ns/user")) ||
+ !PathExists(FilePath("/proc/self/ns/pid"))) {
+ // User or PID namespaces are not supported.
+ return;
+ }
+
+ LaunchOptions options;
+ options.clone_flags = CLONE_NEWUSER | CLONE_NEWPID;
+
+ Process process(SpawnChildWithOptions("CheckPidProcess", options));
+ ASSERT_TRUE(process.IsValid());
+
+ int exit_code = 42;
+ EXPECT_TRUE(process.WaitForExit(&exit_code));
+ EXPECT_EQ(kSuccess, exit_code);
+}
+
+TEST(ForkWithFlagsTest, UpdatesPidCache) {
+ // The libc clone function, which allows ForkWithFlags to keep the pid cache
+ // up to date, does not work on Valgrind.
+ if (RunningOnValgrind()) {
+ return;
+ }
+
+ // Warm up the libc pid cache, if there is one.
+ ASSERT_EQ(syscall(__NR_getpid), getpid());
+
+ pid_t ctid = 0;
+ const pid_t pid = ForkWithFlags(SIGCHLD | CLONE_CHILD_SETTID, nullptr, &ctid);
+ if (pid == 0) {
+ // In child. Check both the raw getpid syscall and the libc getpid wrapper
+ // (which may rely on a pid cache).
+ RAW_CHECK(syscall(__NR_getpid) == ctid);
+ RAW_CHECK(getpid() == ctid);
+ _exit(kSuccess);
+ }
+
+ ASSERT_NE(-1, pid);
+ int status = 42;
+ ASSERT_EQ(pid, HANDLE_EINTR(waitpid(pid, &status, 0)));
+ ASSERT_TRUE(WIFEXITED(status));
+ EXPECT_EQ(kSuccess, WEXITSTATUS(status));
+}
+#endif
+
+#if defined(OS_POSIX) && !defined(OS_ANDROID)
+const char kPipeValue = '\xcc';
+
+class ReadFromPipeDelegate : public LaunchOptions::PreExecDelegate {
+ public:
+ explicit ReadFromPipeDelegate(int fd) : fd_(fd) {}
+ ~ReadFromPipeDelegate() override {}
+ void RunAsyncSafe() override {
+ char c;
+ RAW_CHECK(HANDLE_EINTR(read(fd_, &c, 1)) == 1);
+ RAW_CHECK(IGNORE_EINTR(close(fd_)) == 0);
+ RAW_CHECK(c == kPipeValue);
+ }
+
+ private:
+ int fd_;
+ DISALLOW_COPY_AND_ASSIGN(ReadFromPipeDelegate);
+};
+
+TEST_F(ProcessTest, PreExecHook) {
+ int pipe_fds[2];
+ ASSERT_EQ(0, pipe(pipe_fds));
+
+ ScopedFD read_fd(pipe_fds[0]);
+ ScopedFD write_fd(pipe_fds[1]);
+ base::FileHandleMappingVector fds_to_remap;
+ fds_to_remap.push_back(std::make_pair(read_fd.get(), read_fd.get()));
+
+ ReadFromPipeDelegate read_from_pipe_delegate(read_fd.get());
+ LaunchOptions options;
+ options.fds_to_remap = &fds_to_remap;
+ options.pre_exec_delegate = &read_from_pipe_delegate;
+ Process process(SpawnChildWithOptions("SimpleChildProcess", options));
+ ASSERT_TRUE(process.IsValid());
+
+ read_fd.reset();
+ ASSERT_EQ(1, HANDLE_EINTR(write(write_fd.get(), &kPipeValue, 1)));
+
+ int exit_code = 42;
+ EXPECT_TRUE(process.WaitForExit(&exit_code));
+ EXPECT_EQ(0, exit_code);
+}
+#endif // defined(OS_POSIX) && !defined(OS_ANDROID)
+
} // namespace base
diff --git a/process/process_util_unittest.cc b/process/process_util_unittest.cc
index 80e103d..4b2a575 100644
--- a/process/process_util_unittest.cc
+++ b/process/process_util_unittest.cc
@@ -607,7 +607,7 @@
#else
CHECK_EQ(0, clone_flags);
#endif // OS_LINUX
- EXPECT_TRUE(base::LaunchProcess(args, options, NULL));
+ EXPECT_TRUE(base::LaunchProcess(args, options).IsValid());
PCHECK(IGNORE_EINTR(close(fds[1])) == 0);
char buf[512];
@@ -679,10 +679,8 @@
// Test a non-trival value for clone_flags.
// Don't test on Valgrind as it has limited support for clone().
if (!RunningOnValgrind()) {
- EXPECT_EQ(
- "wibble\n",
- TestLaunchProcess(
- echo_base_test, env_changes, no_clear_environ, CLONE_FS | SIGCHLD));
+ EXPECT_EQ("wibble\n", TestLaunchProcess(echo_base_test, env_changes,
+ no_clear_environ, CLONE_FS));
}
EXPECT_EQ(
diff --git a/process/process_win.cc b/process/process_win.cc
index 96556a9..2c267aa 100644
--- a/process/process_win.cc
+++ b/process/process_win.cc
@@ -9,6 +9,13 @@
#include "base/process/kill.h"
#include "base/win/windows_version.h"
+namespace {
+
+DWORD kBasicProcessAccess =
+ PROCESS_TERMINATE | PROCESS_QUERY_INFORMATION | SYNCHRONIZE;
+
+} // namespace
+
namespace base {
Process::Process(ProcessHandle handle)
@@ -40,6 +47,13 @@
}
// static
+Process Process::OpenWithExtraPriviles(ProcessId pid) {
+ DWORD access = kBasicProcessAccess | PROCESS_DUP_HANDLE | PROCESS_VM_READ;
+ ProcessHandle handle = ::OpenProcess(access, FALSE, pid);
+ return Process(handle);
+}
+
+// static
Process Process::DeprecatedGetProcessFromHandle(ProcessHandle handle) {
DCHECK_NE(handle, ::GetCurrentProcess());
ProcessHandle out_handle;
diff --git a/stl_util_unittest.cc b/stl_util_unittest.cc
index a3f8e16..06ea7cd 100644
--- a/stl_util_unittest.cc
+++ b/stl_util_unittest.cc
@@ -238,5 +238,30 @@
EXPECT_TRUE(STLIncludes<std::set<int> >(a3, a2));
}
+TEST(StringAsArrayTest, Empty) {
+ std::string empty;
+ EXPECT_EQ(nullptr, string_as_array(&empty));
+}
+
+TEST(StringAsArrayTest, NullTerminated) {
+ // If any std::string implementation is not null-terminated, this should
+ // fail. All compilers we use return a null-terminated buffer, but please do
+ // not rely on this fact in your code.
+ std::string str("abcde");
+ str.resize(3);
+ EXPECT_STREQ("abc", string_as_array(&str));
+}
+
+TEST(StringAsArrayTest, WriteCopy) {
+ // With a COW implementation, this test will fail if
+ // string_as_array(&str) is implemented as
+ // const_cast<char*>(str->data()).
+ std::string s1("abc");
+ const std::string s2(s1);
+ string_as_array(&s1)[1] = 'x';
+ EXPECT_EQ("axc", s1);
+ EXPECT_EQ("abc", s2);
+}
+
} // namespace
} // namespace base
diff --git a/test/gtest_util.cc b/test/gtest_util.cc
index 47fd639..f98320c 100644
--- a/test/gtest_util.cc
+++ b/test/gtest_util.cc
@@ -40,4 +40,39 @@
return serializer.Serialize(root);
}
+bool ReadTestNamesFromFile(const FilePath& path,
+ std::vector<SplitTestName>* output) {
+ JSONFileValueSerializer deserializer(path);
+ int error_code = 0;
+ std::string error_message;
+ scoped_ptr<base::Value> value(
+ deserializer.Deserialize(&error_code, &error_message));
+ if (!value.get())
+ return false;
+
+ base::ListValue* tests = nullptr;
+ if (!value->GetAsList(&tests))
+ return false;
+
+ std::vector<base::SplitTestName> result;
+ for (base::ListValue::iterator i = tests->begin(); i != tests->end(); ++i) {
+ base::DictionaryValue* test = nullptr;
+ if (!(*i)->GetAsDictionary(&test))
+ return false;
+
+ std::string test_case_name;
+ if (!test->GetStringASCII("test_case_name", &test_case_name))
+ return false;
+
+ std::string test_name;
+ if (!test->GetStringASCII("test_name", &test_name))
+ return false;
+
+ result.push_back(std::make_pair(test_case_name, test_name));
+ }
+
+ output->swap(result);
+ return true;
+}
+
} // namespace
diff --git a/test/gtest_util.h b/test/gtest_util.h
index 93382f8..d10c72f 100644
--- a/test/gtest_util.h
+++ b/test/gtest_util.h
@@ -26,6 +26,12 @@
// current executable as a JSON file. Returns true on success.
bool WriteCompiledInTestsToFile(const FilePath& path) WARN_UNUSED_RESULT;
+// Reads the list of gtest-based tests from |path| into |output|.
+// Returns true on success.
+bool ReadTestNamesFromFile(
+ const FilePath& path,
+ std::vector<SplitTestName>* output) WARN_UNUSED_RESULT;
+
} // namespace base
#endif // BASE_TEST_GTEST_UTIL_H_
diff --git a/test/launcher/test_launcher.cc b/test/launcher/test_launcher.cc
index af2e461..b5316ad 100644
--- a/test/launcher/test_launcher.cc
+++ b/test/launcher/test_launcher.cc
@@ -829,6 +829,11 @@
}
}
+ if (!launcher_delegate_->GetTests(&tests_)) {
+ LOG(ERROR) << "Failed to get list of tests.";
+ return false;
+ }
+
if (!results_tracker_.Init(*command_line)) {
LOG(ERROR) << "Failed to initialize test results tracker.";
return 1;
@@ -900,12 +905,10 @@
}
void TestLauncher::RunTests() {
- std::vector<SplitTestName> tests(GetCompiledInTests());
-
std::vector<std::string> test_names;
-
- for (size_t i = 0; i < tests.size(); i++) {
- std::string test_name = FormatFullTestName(tests[i].first, tests[i].second);
+ for (size_t i = 0; i < tests_.size(); i++) {
+ std::string test_name = FormatFullTestName(
+ tests_[i].first, tests_[i].second);
results_tracker_.AddTest(test_name);
@@ -918,7 +921,7 @@
continue;
}
- if (!launcher_delegate_->ShouldRunTest(tests[i].first, tests[i].second))
+ if (!launcher_delegate_->ShouldRunTest(tests_[i].first, tests_[i].second))
continue;
// Skip the test that doesn't match the filter (if given).
diff --git a/test/launcher/test_launcher.h b/test/launcher/test_launcher.h
index 78a854b..27909d4 100644
--- a/test/launcher/test_launcher.h
+++ b/test/launcher/test_launcher.h
@@ -11,6 +11,7 @@
#include "base/basictypes.h"
#include "base/callback_forward.h"
#include "base/compiler_specific.h"
+#include "base/test/gtest_util.h"
#include "base/test/launcher/test_result.h"
#include "base/test/launcher/test_results_tracker.h"
#include "base/time/time.h"
@@ -40,6 +41,10 @@
// which tests and how are run.
class TestLauncherDelegate {
public:
+ // Called to get names of tests available for running. The delegate
+ // must put the result in |output| and return true on success.
+ virtual bool GetTests(std::vector<SplitTestName>* output) = 0;
+
// Called before a test is considered for running. If it returns false,
// the test is not run. If it returns true, the test will be run provided
// it is part of the current shard.
@@ -158,6 +163,9 @@
std::vector<std::string> positive_test_filter_;
std::vector<std::string> negative_test_filter_;
+ // Tests to use (cached result of TestLauncherDelegate::GetTests).
+ std::vector<SplitTestName> tests_;
+
// Number of tests started in this iteration.
size_t test_started_count_;
diff --git a/test/launcher/test_launcher_ios.cc b/test/launcher/test_launcher_ios.cc
index 39051ca..82353cc 100644
--- a/test/launcher/test_launcher_ios.cc
+++ b/test/launcher/test_launcher_ios.cc
@@ -5,18 +5,152 @@
#include "base/test/launcher/test_launcher.h"
#include "base/at_exit.h"
+#include "base/base_paths.h"
#include "base/bind.h"
+#include "base/command_line.h"
+#include "base/files/file_path.h"
+#include "base/files/file_util.h"
+#include "base/files/scoped_temp_dir.h"
+#include "base/format_macros.h"
+#include "base/message_loop/message_loop.h"
+#include "base/path_service.h"
+#include "base/process/launch.h"
#include "base/test/launcher/unit_test_launcher.h"
+#include "base/test/test_switches.h"
+#include "base/test/test_timeouts.h"
namespace {
-int DummyRunTestSuite(void) {
- return -1;
+const char kHelpFlag[] = "help";
+
+void PrintUsage() {
+ fprintf(stdout,
+ "Runs tests using the gtest framework, each batch of tests being\n"
+ "run in their own process. Supported command-line flags:\n"
+ "\n"
+ " Common flags:\n"
+ " --gtest_filter=...\n"
+ " Runs a subset of tests (see --gtest_help for more info).\n"
+ "\n"
+ " --help\n"
+ " Shows this message.\n"
+ "\n"
+ " Other flags:\n"
+ " --test-launcher-retry-limit=N\n"
+ " Sets the limit of test retries on failures to N.\n"
+ "\n"
+ " --test-launcher-summary-output=PATH\n"
+ " Saves a JSON machine-readable summary of the run.\n"
+ "\n"
+ " --test-launcher-print-test-stdio=auto|always|never\n"
+ " Controls when full test output is printed.\n"
+ " auto means to print it when the test failed.\n"
+ "\n"
+ " --test-launcher-total-shards=N\n"
+ " Sets the total number of shards to N.\n"
+ "\n"
+ " --test-launcher-shard-index=N\n"
+ " Sets the shard index to run to N (from 0 to TOTAL - 1).\n");
+ fflush(stdout);
}
+class IOSUnitTestLauncherDelegate : public base::UnitTestLauncherDelegate {
+ public:
+ IOSUnitTestLauncherDelegate() : base::UnitTestLauncherDelegate(0, false) {
+ }
+
+ bool Init() WARN_UNUSED_RESULT {
+ if (!PathService::Get(base::DIR_EXE, &dir_exe_)) {
+ LOG(ERROR) << "Failed to get directory of current executable.";
+ return false;
+ }
+
+ base::CommandLine* command_line = base::CommandLine::ForCurrentProcess();
+ std::vector<std::string> args(command_line->GetArgs());
+ if (args.size() < 1) {
+ LOG(ERROR) << "Arguments expected.";
+ return false;
+ }
+ test_name_ = args[0];
+
+ base::CommandLine cmd_line(dir_exe_.AppendASCII(test_name_ + ".app"));
+ cmd_line.AppendSwitch(switches::kTestLauncherPrintWritablePath);
+ cmd_line.PrependWrapper(dir_exe_.AppendASCII("iossim").value());
+
+ std::string raw_output;
+ if (!base::GetAppOutput(cmd_line, &raw_output)) {
+ LOG(ERROR) << "GetAppOutput failed.";
+ return false;
+ }
+ writable_path_ = base::FilePath(raw_output);
+
+ return true;
+ }
+
+ bool GetTests(std::vector<base::SplitTestName>* output) override {
+ base::ScopedTempDir temp_dir;
+ if (!temp_dir.CreateUniqueTempDirUnderPath(writable_path_))
+ return false;
+ base::FilePath test_list_path(
+ temp_dir.path().AppendASCII("test_list.json"));
+
+ base::CommandLine cmd_line(dir_exe_.AppendASCII(test_name_ + ".app"));
+ cmd_line.AppendSwitchPath(switches::kTestLauncherListTests, test_list_path);
+ cmd_line.PrependWrapper(dir_exe_.AppendASCII("iossim").value());
+
+ base::LaunchOptions launch_options;
+ launch_options.wait = true;
+
+ if (!base::LaunchProcess(cmd_line, launch_options).IsValid())
+ return false;
+
+ return base::ReadTestNamesFromFile(test_list_path, output);
+ }
+
+ private:
+ // Directory containing test launcher's executable.
+ base::FilePath dir_exe_;
+
+ // Name of the test executable to run.
+ std::string test_name_;
+
+ // Path that launched test binary can write to.
+ base::FilePath writable_path_;
+
+ DISALLOW_COPY_AND_ASSIGN(IOSUnitTestLauncherDelegate);
+};
+
} // namespace
int main(int argc, char** argv) {
base::AtExitManager at_exit;
- return base::LaunchUnitTests(argc, argv, base::Bind(&DummyRunTestSuite));
+
+ base::CommandLine::Init(argc, argv);
+
+ if (base::CommandLine::ForCurrentProcess()->HasSwitch(kHelpFlag)) {
+ PrintUsage();
+ return 0;
+ }
+
+ base::TimeTicks start_time(base::TimeTicks::Now());
+
+ TestTimeouts::Initialize();
+
+ base::MessageLoopForIO message_loop;
+
+ IOSUnitTestLauncherDelegate delegate;
+ if (!delegate.Init()) {
+ fprintf(stderr, "Failed to intialize test launcher delegate.\n");
+ fflush(stderr);
+ return 1;
+ }
+ // Force one job since we can't run multiple simulators in parallel.
+ base::TestLauncher launcher(&delegate, 1);
+ bool success = launcher.Run();
+
+ fprintf(stdout, "Tests took %" PRId64 " seconds.\n",
+ (base::TimeTicks::Now() - start_time).InSeconds());
+ fflush(stdout);
+
+ return (success ? 0 : 1);
}
diff --git a/test/launcher/unit_test_launcher.cc b/test/launcher/unit_test_launcher.cc
index 6309cde..9a8b41f 100644
--- a/test/launcher/unit_test_launcher.cc
+++ b/test/launcher/unit_test_launcher.cc
@@ -100,34 +100,159 @@
return new_cmd_line;
}
-class UnitTestLauncherDelegate : public TestLauncherDelegate {
- public:
- explicit UnitTestLauncherDelegate(size_t batch_limit, bool use_job_objects)
- : batch_limit_(batch_limit),
- use_job_objects_(use_job_objects) {
+bool GetSwitchValueAsInt(const std::string& switch_name, int* result) {
+ if (!CommandLine::ForCurrentProcess()->HasSwitch(switch_name))
+ return true;
+
+ std::string switch_value =
+ CommandLine::ForCurrentProcess()->GetSwitchValueASCII(switch_name);
+ if (!StringToInt(switch_value, result) || *result < 1) {
+ LOG(ERROR) << "Invalid value for " << switch_name << ": " << switch_value;
+ return false;
}
- ~UnitTestLauncherDelegate() override {
- DCHECK(thread_checker_.CalledOnValidThread());
+ return true;
+}
+
+int LaunchUnitTestsInternal(const RunTestSuiteCallback& run_test_suite,
+ int default_jobs,
+ bool use_job_objects,
+ const Closure& gtest_init) {
+#if defined(OS_ANDROID)
+ // We can't easily fork on Android, just run the test suite directly.
+ return run_test_suite.Run();
+#else
+ bool force_single_process = false;
+ if (CommandLine::ForCurrentProcess()->HasSwitch(
+ switches::kTestLauncherDebugLauncher)) {
+ fprintf(stdout, "Forcing test launcher debugging mode.\n");
+ fflush(stdout);
+ } else {
+ if (base::debug::BeingDebugged()) {
+ fprintf(stdout,
+ "Debugger detected, switching to single process mode.\n"
+ "Pass --test-launcher-debug-launcher to debug the launcher "
+ "itself.\n");
+ fflush(stdout);
+ force_single_process = true;
+ }
}
- private:
- struct GTestCallbackState {
- TestLauncher* test_launcher;
- std::vector<std::string> test_names;
- FilePath output_file;
- };
+ if (CommandLine::ForCurrentProcess()->HasSwitch(kGTestHelpFlag) ||
+ CommandLine::ForCurrentProcess()->HasSwitch(kGTestListTestsFlag) ||
+ CommandLine::ForCurrentProcess()->HasSwitch(kSingleProcessTestsFlag) ||
+ force_single_process) {
+ return run_test_suite.Run();
+ }
+#endif
- bool ShouldRunTest(const std::string& test_case_name,
- const std::string& test_name) override {
+ if (CommandLine::ForCurrentProcess()->HasSwitch(kHelpFlag)) {
+ PrintUsage();
+ return 0;
+ }
+
+ base::TimeTicks start_time(base::TimeTicks::Now());
+
+ gtest_init.Run();
+ TestTimeouts::Initialize();
+
+ int batch_limit = kDefaultTestBatchLimit;
+ if (!GetSwitchValueAsInt(switches::kTestLauncherBatchLimit, &batch_limit))
+ return 1;
+
+ fprintf(stdout,
+ "IMPORTANT DEBUGGING NOTE: batches of tests are run inside their\n"
+ "own process. For debugging a test inside a debugger, use the\n"
+ "--gtest_filter=<your_test_name> flag along with\n"
+ "--single-process-tests.\n");
+ fflush(stdout);
+
+ MessageLoopForIO message_loop;
+
+ UnitTestLauncherDelegate delegate(batch_limit, use_job_objects);
+ base::TestLauncher launcher(&delegate, default_jobs);
+ bool success = launcher.Run();
+
+ fprintf(stdout, "Tests took %" PRId64 " seconds.\n",
+ (base::TimeTicks::Now() - start_time).InSeconds());
+ fflush(stdout);
+
+ return (success ? 0 : 1);
+}
+
+void InitGoogleTestChar(int* argc, char** argv) {
+ testing::InitGoogleTest(argc, argv);
+}
+
+#if defined(OS_WIN)
+void InitGoogleTestWChar(int* argc, wchar_t** argv) {
+ testing::InitGoogleTest(argc, argv);
+}
+#endif // defined(OS_WIN)
+
+} // namespace
+
+int LaunchUnitTests(int argc,
+ char** argv,
+ const RunTestSuiteCallback& run_test_suite) {
+ CommandLine::Init(argc, argv);
+ return LaunchUnitTestsInternal(run_test_suite, SysInfo::NumberOfProcessors(),
+ true, Bind(&InitGoogleTestChar, &argc, argv));
+}
+
+int LaunchUnitTestsSerially(int argc,
+ char** argv,
+ const RunTestSuiteCallback& run_test_suite) {
+ CommandLine::Init(argc, argv);
+ return LaunchUnitTestsInternal(run_test_suite, 1, true,
+ Bind(&InitGoogleTestChar, &argc, argv));
+}
+
+#if defined(OS_WIN)
+int LaunchUnitTests(int argc,
+ wchar_t** argv,
+ bool use_job_objects,
+ const RunTestSuiteCallback& run_test_suite) {
+ // Windows CommandLine::Init ignores argv anyway.
+ CommandLine::Init(argc, NULL);
+ return LaunchUnitTestsInternal(run_test_suite, SysInfo::NumberOfProcessors(),
+ use_job_objects,
+ Bind(&InitGoogleTestWChar, &argc, argv));
+}
+#endif // defined(OS_WIN)
+
+UnitTestLauncherDelegate::UnitTestLauncherDelegate(size_t batch_limit,
+ bool use_job_objects)
+ : batch_limit_(batch_limit), use_job_objects_(use_job_objects) {
+}
+
+UnitTestLauncherDelegate::~UnitTestLauncherDelegate() {
+ DCHECK(thread_checker_.CalledOnValidThread());
+}
+
+UnitTestLauncherDelegate::GTestCallbackState::GTestCallbackState() {
+}
+
+UnitTestLauncherDelegate::GTestCallbackState::~GTestCallbackState() {
+}
+
+bool UnitTestLauncherDelegate::GetTests(std::vector<SplitTestName>* output) {
+ DCHECK(thread_checker_.CalledOnValidThread());
+ *output = GetCompiledInTests();
+ return true;
+}
+
+bool UnitTestLauncherDelegate::ShouldRunTest(const std::string& test_case_name,
+ const std::string& test_name) {
DCHECK(thread_checker_.CalledOnValidThread());
// There is no additional logic to disable specific tests.
return true;
}
- size_t RunTests(TestLauncher* test_launcher,
- const std::vector<std::string>& test_names) override {
+ size_t UnitTestLauncherDelegate::RunTests(
+ TestLauncher* test_launcher,
+ const std::vector<std::string>& test_names) {
DCHECK(thread_checker_.CalledOnValidThread());
std::vector<std::string> batch;
@@ -145,8 +270,9 @@
return test_names.size();
}
- size_t RetryTests(TestLauncher* test_launcher,
- const std::vector<std::string>& test_names) override {
+ size_t UnitTestLauncherDelegate::RetryTests(
+ TestLauncher* test_launcher,
+ const std::vector<std::string>& test_names) {
MessageLoop::current()->PostTask(
FROM_HERE,
Bind(&UnitTestLauncherDelegate::RunSerially,
@@ -156,8 +282,9 @@
return test_names.size();
}
- void RunSerially(TestLauncher* test_launcher,
- const std::vector<std::string>& test_names) {
+ void UnitTestLauncherDelegate::RunSerially(
+ TestLauncher* test_launcher,
+ const std::vector<std::string>& test_names) {
if (test_names.empty())
return;
@@ -193,8 +320,9 @@
new_test_names));
}
- void RunBatch(TestLauncher* test_launcher,
- const std::vector<std::string>& test_names) {
+ void UnitTestLauncherDelegate::RunBatch(
+ TestLauncher* test_launcher,
+ const std::vector<std::string>& test_names) {
DCHECK(thread_checker_.CalledOnValidThread());
if (test_names.empty())
@@ -234,11 +362,12 @@
callback_state));
}
- void GTestCallback(const GTestCallbackState& callback_state,
- int exit_code,
- const TimeDelta& elapsed_time,
- bool was_timeout,
- const std::string& output) {
+ void UnitTestLauncherDelegate::GTestCallback(
+ const GTestCallbackState& callback_state,
+ int exit_code,
+ const TimeDelta& elapsed_time,
+ bool was_timeout,
+ const std::string& output) {
DCHECK(thread_checker_.CalledOnValidThread());
std::vector<std::string> tests_to_relaunch;
ProcessTestResults(callback_state.test_launcher,
@@ -262,12 +391,13 @@
DeleteFile(callback_state.output_file.DirName(), true);
}
- void SerialGTestCallback(const GTestCallbackState& callback_state,
- const std::vector<std::string>& test_names,
- int exit_code,
- const TimeDelta& elapsed_time,
- bool was_timeout,
- const std::string& output) {
+ void UnitTestLauncherDelegate::SerialGTestCallback(
+ const GTestCallbackState& callback_state,
+ const std::vector<std::string>& test_names,
+ int exit_code,
+ const TimeDelta& elapsed_time,
+ bool was_timeout,
+ const std::string& output) {
DCHECK(thread_checker_.CalledOnValidThread());
std::vector<std::string> tests_to_relaunch;
bool called_any_callbacks =
@@ -297,7 +427,8 @@
test_names));
}
- static bool ProcessTestResults(
+ // static
+ bool UnitTestLauncherDelegate::ProcessTestResults(
TestLauncher* test_launcher,
const std::vector<std::string>& test_names,
const base::FilePath& output_file,
@@ -434,143 +565,4 @@
return called_any_callback;
}
- ThreadChecker thread_checker_;
-
- // Maximum number of tests to run in a single batch.
- size_t batch_limit_;
-
- // Determines whether we use job objects on Windows.
- bool use_job_objects_;
-};
-
-bool GetSwitchValueAsInt(const std::string& switch_name, int* result) {
- if (!CommandLine::ForCurrentProcess()->HasSwitch(switch_name))
- return true;
-
- std::string switch_value =
- CommandLine::ForCurrentProcess()->GetSwitchValueASCII(switch_name);
- if (!StringToInt(switch_value, result) || *result < 1) {
- LOG(ERROR) << "Invalid value for " << switch_name << ": " << switch_value;
- return false;
- }
-
- return true;
-}
-
-int LaunchUnitTestsInternal(const RunTestSuiteCallback& run_test_suite,
- int default_jobs,
- bool use_job_objects,
- const Closure& gtest_init) {
-#if defined(OS_ANDROID)
- // We can't easily fork on Android, just run the test suite directly.
- return run_test_suite.Run();
-#else
- bool force_single_process = false;
- if (CommandLine::ForCurrentProcess()->HasSwitch(
- switches::kTestLauncherDebugLauncher)) {
- fprintf(stdout, "Forcing test launcher debugging mode.\n");
- fflush(stdout);
- } else {
- if (base::debug::BeingDebugged()) {
- fprintf(stdout,
- "Debugger detected, switching to single process mode.\n"
- "Pass --test-launcher-debug-launcher to debug the launcher "
- "itself.\n");
- fflush(stdout);
- force_single_process = true;
- }
- }
-
- if (CommandLine::ForCurrentProcess()->HasSwitch(kGTestHelpFlag) ||
- CommandLine::ForCurrentProcess()->HasSwitch(kGTestListTestsFlag) ||
- CommandLine::ForCurrentProcess()->HasSwitch(kSingleProcessTestsFlag) ||
- force_single_process) {
- return run_test_suite.Run();
- }
-#endif
-
- if (CommandLine::ForCurrentProcess()->HasSwitch(kHelpFlag)) {
- PrintUsage();
- return 0;
- }
-
- base::TimeTicks start_time(base::TimeTicks::Now());
-
- gtest_init.Run();
- TestTimeouts::Initialize();
-
- int batch_limit = kDefaultTestBatchLimit;
- if (!GetSwitchValueAsInt(switches::kTestLauncherBatchLimit, &batch_limit))
- return 1;
-
- fprintf(stdout,
- "IMPORTANT DEBUGGING NOTE: batches of tests are run inside their\n"
- "own process. For debugging a test inside a debugger, use the\n"
- "--gtest_filter=<your_test_name> flag along with\n"
- "--single-process-tests.\n");
- fflush(stdout);
-
- MessageLoopForIO message_loop;
-
- UnitTestLauncherDelegate delegate(batch_limit, use_job_objects);
- base::TestLauncher launcher(&delegate, default_jobs);
- bool success = launcher.Run();
-
- fprintf(stdout,
- "Tests took %" PRId64 " seconds.\n",
- (base::TimeTicks::Now() - start_time).InSeconds());
- fflush(stdout);
-
- return (success ? 0 : 1);
-}
-
-void InitGoogleTestChar(int* argc, char** argv) {
- testing::InitGoogleTest(argc, argv);
-}
-
-#if defined(OS_WIN)
-void InitGoogleTestWChar(int* argc, wchar_t** argv) {
- testing::InitGoogleTest(argc, argv);
-}
-#endif // defined(OS_WIN)
-
-} // namespace
-
-int LaunchUnitTests(int argc,
- char** argv,
- const RunTestSuiteCallback& run_test_suite) {
- CommandLine::Init(argc, argv);
- return LaunchUnitTestsInternal(
- run_test_suite,
- SysInfo::NumberOfProcessors(),
- true,
- Bind(&InitGoogleTestChar, &argc, argv));
-}
-
-int LaunchUnitTestsSerially(int argc,
- char** argv,
- const RunTestSuiteCallback& run_test_suite) {
- CommandLine::Init(argc, argv);
- return LaunchUnitTestsInternal(
- run_test_suite,
- 1,
- true,
- Bind(&InitGoogleTestChar, &argc, argv));
-}
-
-#if defined(OS_WIN)
-int LaunchUnitTests(int argc,
- wchar_t** argv,
- bool use_job_objects,
- const RunTestSuiteCallback& run_test_suite) {
- // Windows CommandLine::Init ignores argv anyway.
- CommandLine::Init(argc, NULL);
- return LaunchUnitTestsInternal(
- run_test_suite,
- SysInfo::NumberOfProcessors(),
- use_job_objects,
- Bind(&InitGoogleTestWChar, &argc, argv));
-}
-#endif // defined(OS_WIN)
-
} // namespace base
diff --git a/test/launcher/unit_test_launcher.h b/test/launcher/unit_test_launcher.h
index 5682ed9..0f661db 100644
--- a/test/launcher/unit_test_launcher.h
+++ b/test/launcher/unit_test_launcher.h
@@ -6,6 +6,8 @@
#define BASE_TEST_LAUNCHER_UNIT_TEST_LAUNCHER_H_
#include "base/callback.h"
+#include "base/files/file_path.h"
+#include "base/test/launcher/test_launcher.h"
namespace base {
@@ -31,6 +33,75 @@
const RunTestSuiteCallback& run_test_suite);
#endif // defined(OS_WIN)
+// Test launcher delegate for unit tests (mostly to support batching).
+class UnitTestLauncherDelegate : public TestLauncherDelegate {
+ public:
+ explicit UnitTestLauncherDelegate(size_t batch_limit, bool use_job_objects);
+ ~UnitTestLauncherDelegate() override;
+
+ private:
+ struct GTestCallbackState {
+ GTestCallbackState();
+ ~GTestCallbackState();
+
+ TestLauncher* test_launcher;
+ std::vector<std::string> test_names;
+ FilePath output_file;
+ };
+
+ // TestLauncherDelegate:
+ bool GetTests(std::vector<SplitTestName>* output) override;
+ bool ShouldRunTest(const std::string& test_case_name,
+ const std::string& test_name) override;
+ size_t RunTests(TestLauncher* test_launcher,
+ const std::vector<std::string>& test_names) override;
+ size_t RetryTests(TestLauncher* test_launcher,
+ const std::vector<std::string>& test_names) override;
+
+ // Runs tests serially, each in its own process.
+ void RunSerially(TestLauncher* test_launcher,
+ const std::vector<std::string>& test_names);
+
+ // Runs tests in batches (each batch in its own process).
+ void RunBatch(TestLauncher* test_launcher,
+ const std::vector<std::string>& test_names);
+
+ // Callback for batched tests.
+ void GTestCallback(const GTestCallbackState& callback_state,
+ int exit_code,
+ const TimeDelta& elapsed_time,
+ bool was_timeout,
+ const std::string& output);
+
+ // Callback for serialized tests.
+ void SerialGTestCallback(const GTestCallbackState& callback_state,
+ const std::vector<std::string>& test_names,
+ int exit_code,
+ const TimeDelta& elapsed_time,
+ bool was_timeout,
+ const std::string& output);
+
+ // Interprets test results and reports to the test launcher. Returns true
+ // on success.
+ static bool ProcessTestResults(TestLauncher* test_launcher,
+ const std::vector<std::string>& test_names,
+ const base::FilePath& output_file,
+ const std::string& output,
+ int exit_code,
+ bool was_timeout,
+ std::vector<std::string>* tests_to_relaunch);
+
+ ThreadChecker thread_checker_;
+
+ // Maximum number of tests to run in a single batch.
+ size_t batch_limit_;
+
+ // Determines whether we use job objects on Windows.
+ bool use_job_objects_;
+
+ DISALLOW_COPY_AND_ASSIGN(UnitTestLauncherDelegate);
+};
+
} // namespace base
#endif // BASE_TEST_LAUNCHER_UNIT_TEST_LAUNCHER_H_
diff --git a/test/launcher/unit_test_launcher_ios.cc b/test/launcher/unit_test_launcher_ios.cc
index d4276c8..acb6c71 100644
--- a/test/launcher/unit_test_launcher_ios.cc
+++ b/test/launcher/unit_test_launcher_ios.cc
@@ -6,7 +6,9 @@
#include "base/command_line.h"
#include "base/files/file_path.h"
+#include "base/files/file_util.h"
#include "base/logging.h"
+#include "base/mac/foundation_util.h"
#include "base/test/gtest_util.h"
#include "base/test/test_switches.h"
@@ -27,6 +29,11 @@
LOG(ERROR) << "Failed to write list of tests.";
return 1;
}
+ } else if (command_line->HasSwitch(
+ switches::kTestLauncherPrintWritablePath)) {
+ fprintf(stdout, "%s", mac::GetUserLibraryPath().value().c_str());
+ fflush(stdout);
+ return 0;
}
return run_test_suite.Run();
diff --git a/test/test_suite.cc b/test/test_suite.cc
index 383b82c..a6fc201 100644
--- a/test/test_suite.cc
+++ b/test/test_suite.cc
@@ -135,12 +135,12 @@
testing::GTEST_FLAG(catch_exceptions) = false;
#endif
base::EnableTerminationOnHeapCorruption();
-#if defined(OS_LINUX) && !defined(OS_ANDROID)
+#if defined(OS_LINUX) && defined(USE_AURA)
// When calling native char conversion functions (e.g wrctomb) we need to
// have the locale set. In the absence of such a call the "C" locale is the
// default. In the gtk code (below) gtk_init() implicitly sets a locale.
setlocale(LC_ALL, "");
-#endif // defined(OS_LINUX) && !defined(OS_ANDROID)
+#endif // defined(OS_LINUX) && defined(USE_AURA)
// On Android, AtExitManager is created in
// testing/android/native_test_wrapper.cc before main() is called.
diff --git a/test/test_switches.cc b/test/test_switches.cc
index 4d8331d..84aa53c 100644
--- a/test/test_switches.cc
+++ b/test/test_switches.cc
@@ -42,6 +42,10 @@
const char switches::kTestLauncherPrintTestStdio[] =
"test-launcher-print-test-stdio";
+// Print a writable path and exit (for internal use).
+const char switches::kTestLauncherPrintWritablePath[] =
+ "test-launcher-print-writable-path";
+
// Index of the test shard to run, starting from 0 (first shard) to total shards
// minus one (last shard).
const char switches::kTestLauncherShardIndex[] =
diff --git a/test/test_switches.h b/test/test_switches.h
index 336d036..f145f1e 100644
--- a/test/test_switches.h
+++ b/test/test_switches.h
@@ -19,6 +19,7 @@
extern const char kTestLauncherRetryLimit[];
extern const char kTestLauncherSummaryOutput[];
extern const char kTestLauncherPrintTestStdio[];
+extern const char kTestLauncherPrintWritablePath[];
extern const char kTestLauncherShardIndex[];
extern const char kTestLauncherTotalShards[];
extern const char kTestLauncherTimeout[];
diff --git a/test/test_timeouts.cc b/test/test_timeouts.cc
index 66ae85e..b30d6c3 100644
--- a/test/test_timeouts.cc
+++ b/test/test_timeouts.cc
@@ -23,7 +23,7 @@
#elif defined(ADDRESS_SANITIZER) && defined(OS_WIN)
// Asan/Win has not been optimized yet, give it a higher
// timeout multiplier. See http://crbug.com/412471
-static const int kTimeoutMultiplier = 8;
+static const int kTimeoutMultiplier = 3;
#elif defined(ADDRESS_SANITIZER) || defined(THREAD_SANITIZER) || \
defined(SYZYASAN)
static const int kTimeoutMultiplier = 2;
diff --git a/time/time.h b/time/time.h
index d61a351..915eac8 100644
--- a/time/time.h
+++ b/time/time.h
@@ -100,6 +100,15 @@
return delta_;
}
+ // Returns the magnitude (absolute value) of this TimeDelta.
+ TimeDelta magnitude() const {
+ // Some toolchains provide an incomplete C++11 implementation and lack an
+ // int64 overload for std::abs(). The following is a simple branchless
+ // implementation:
+ const int64 mask = delta_ >> (sizeof(delta_) * 8 - 1);
+ return TimeDelta((delta_ + mask) ^ mask);
+ }
+
// Returns true if the time delta is the maximum time delta.
bool is_max() const {
return delta_ == std::numeric_limits<int64>::max();
@@ -588,18 +597,26 @@
TimeTicks() : ticks_(0) {
}
- // Platform-dependent tick count representing "right now."
- // The resolution of this clock is ~1-15ms. Resolution varies depending
- // on hardware/operating system configuration.
+ // Platform-dependent tick count representing "right now." When
+ // IsHighResolution() returns false, the resolution of the clock could be
+ // as coarse as ~15.6ms. Otherwise, the resolution should be no worse than one
+ // microsecond.
static TimeTicks Now();
- // Returns a platform-dependent high-resolution tick count. Implementation
- // is hardware dependent and may or may not return sub-millisecond
- // resolution. THIS CALL IS GENERALLY MUCH MORE EXPENSIVE THAN Now() AND
- // SHOULD ONLY BE USED WHEN IT IS REALLY NEEDED.
- static TimeTicks HighResNow();
+ // DEPRECATED
+ // TODO(miu): Remove this function, and all callpoints should call Now().
+ static TimeTicks HighResNow() { return TimeTicks::Now(); }
- static bool IsHighResNowFastAndReliable();
+ // Returns true if the high resolution clock is working on this system and
+ // Now() will return high resolution values. Note that, on systems where the
+ // high resolution clock works but is deemed inefficient, the low resolution
+ // clock will be used instead.
+ static bool IsHighResolution();
+
+ // DEPRECATED
+ // TODO(miu): Remove this function, and all callpoints should call
+ // IsHighResolution().
+ static bool IsHighResNowFastAndReliable() { return IsHighResolution(); }
// Returns true if ThreadNow() is supported on this system.
static bool IsThreadNowSupported() {
@@ -616,24 +633,33 @@
// to (approximately) measure how much time the calling thread spent doing
// actual work vs. being de-scheduled. May return bogus results if the thread
// migrates to another CPU between two calls.
+ //
+ // WARNING: The returned value might NOT have the same origin as Now(). Do not
+ // perform math between TimeTicks values returned by Now() and ThreadNow() and
+ // expect meaningful results.
+ // TODO(miu): Since the timeline of these values is different, the values
+ // should be of a different type.
static TimeTicks ThreadNow();
- // Returns the current system trace time or, if none is defined, the current
- // high-res time (i.e. HighResNow()). On systems where a global trace clock
- // is defined, timestamping TraceEvents's with this value guarantees
- // synchronization between events collected inside chrome and events
- // collected outside (e.g. kernel, X server).
+ // Returns the current system trace time or, if not available on this
+ // platform, a high-resolution time value; or a low-resolution time value if
+ // neither are avalable. On systems where a global trace clock is defined,
+ // timestamping TraceEvents's with this value guarantees synchronization
+ // between events collected inside chrome and events collected outside
+ // (e.g. kernel, X server).
+ //
+ // WARNING: The returned value might NOT have the same origin as Now(). Do not
+ // perform math between TimeTicks values returned by Now() and
+ // NowFromSystemTraceTime() and expect meaningful results.
+ // TODO(miu): Since the timeline of these values is different, the values
+ // should be of a different type.
static TimeTicks NowFromSystemTraceTime();
#if defined(OS_WIN)
- // Get the absolute value of QPC time drift. For testing.
- static int64 GetQPCDriftMicroseconds();
-
+ // Translates an absolute QPC timestamp into a TimeTicks value. The returned
+ // value has the same origin as Now(). Do NOT attempt to use this if
+ // IsHighResolution() returns false.
static TimeTicks FromQPCValue(LONGLONG qpc_value);
-
- // Returns true if the high resolution clock is working on this system.
- // This is only for testing.
- static bool IsHighResClockWorking();
#endif
// Returns true if this object has not been initialized.
diff --git a/time/time_mac.cc b/time/time_mac.cc
index 26c5d7a..3944d06 100644
--- a/time/time_mac.cc
+++ b/time/time_mac.cc
@@ -219,12 +219,7 @@
}
// static
-TimeTicks TimeTicks::HighResNow() {
- return Now();
-}
-
-// static
-bool TimeTicks::IsHighResNowFastAndReliable() {
+bool TimeTicks::IsHighResolution() {
return true;
}
diff --git a/time/time_posix.cc b/time/time_posix.cc
index ad00c51..34b2f5a 100644
--- a/time/time_posix.cc
+++ b/time/time_posix.cc
@@ -314,12 +314,7 @@
}
// static
-TimeTicks TimeTicks::HighResNow() {
- return Now();
-}
-
-// static
-bool TimeTicks::IsHighResNowFastAndReliable() {
+bool TimeTicks::IsHighResolution() {
return true;
}
diff --git a/time/time_unittest.cc b/time/time_unittest.cc
index 16d6fe9..07b1e6b 100644
--- a/time/time_unittest.cc
+++ b/time/time_unittest.cc
@@ -6,6 +6,7 @@
#include <time.h>
+#include <limits>
#include <string>
#include "base/compiler_specific.h"
@@ -642,12 +643,10 @@
}
static void HighResClockTest(TimeTicks (*GetTicks)()) {
-#if defined(OS_WIN)
// HighResNow doesn't work on some systems. Since the product still works
// even if it doesn't work, it makes this entire test questionable.
- if (!TimeTicks::IsHighResClockWorking())
+ if (!TimeTicks::IsHighResolution())
return;
-#endif
// Why do we loop here?
// We're trying to measure that intervals increment in a VERY small amount
@@ -792,6 +791,26 @@
return oss.str();
}
+TEST(TimeDelta, Magnitude) {
+ const int64 zero = 0;
+ EXPECT_EQ(TimeDelta::FromMicroseconds(zero),
+ TimeDelta::FromMicroseconds(zero).magnitude());
+
+ const int64 one = 1;
+ const int64 negative_one = -1;
+ EXPECT_EQ(TimeDelta::FromMicroseconds(one),
+ TimeDelta::FromMicroseconds(one).magnitude());
+ EXPECT_EQ(TimeDelta::FromMicroseconds(one),
+ TimeDelta::FromMicroseconds(negative_one).magnitude());
+
+ const int64 max_int64_minus_one = std::numeric_limits<int64>::max() - 1;
+ const int64 min_int64_plus_two = std::numeric_limits<int64>::min() + 2;
+ EXPECT_EQ(TimeDelta::FromMicroseconds(max_int64_minus_one),
+ TimeDelta::FromMicroseconds(max_int64_minus_one).magnitude());
+ EXPECT_EQ(TimeDelta::FromMicroseconds(max_int64_minus_one),
+ TimeDelta::FromMicroseconds(min_int64_plus_two).magnitude());
+}
+
TEST(TimeDeltaLogging, DCheckEqCompiles) {
DCHECK_EQ(TimeDelta(), TimeDelta());
}
diff --git a/time/time_win.cc b/time/time_win.cc
index 9b4f17d..8ae7640 100644
--- a/time/time_win.cc
+++ b/time/time_win.cc
@@ -307,13 +307,13 @@
return timeGetTime();
}
-DWORD (*tick_function)(void) = &timeGetTimeWrapper;
+DWORD (*g_tick_function)(void) = &timeGetTimeWrapper;
// Accumulation of time lost due to rollover (in milliseconds).
-int64 rollover_ms = 0;
+int64 g_rollover_ms = 0;
// The last timeGetTime value we saw, to detect rollover.
-DWORD last_seen_now = 0;
+DWORD g_last_seen_now = 0;
// Lock protecting rollover_ms and last_seen_now.
// Note: this is a global object, and we usually avoid these. However, the time
@@ -321,169 +321,161 @@
// easy to use a Singleton without even knowing it, and that may lead to many
// gotchas). Its impact on startup time should be negligible due to low-level
// nature of time code.
-base::Lock rollover_lock;
+base::Lock g_rollover_lock;
// We use timeGetTime() to implement TimeTicks::Now(). This can be problematic
// because it returns the number of milliseconds since Windows has started,
// which will roll over the 32-bit value every ~49 days. We try to track
// rollover ourselves, which works if TimeTicks::Now() is called at least every
// 49 days.
-TimeDelta RolloverProtectedNow() {
- base::AutoLock locked(rollover_lock);
+TimeTicks RolloverProtectedNow() {
+ base::AutoLock locked(g_rollover_lock);
// We should hold the lock while calling tick_function to make sure that
// we keep last_seen_now stay correctly in sync.
- DWORD now = tick_function();
- if (now < last_seen_now)
- rollover_ms += 0x100000000I64; // ~49.7 days.
- last_seen_now = now;
- return TimeDelta::FromMilliseconds(now + rollover_ms);
+ DWORD now = g_tick_function();
+ if (now < g_last_seen_now)
+ g_rollover_ms += 0x100000000I64; // ~49.7 days.
+ g_last_seen_now = now;
+ return TimeTicks() + TimeDelta::FromMilliseconds(now + g_rollover_ms);
}
-bool IsBuggyAthlon(const base::CPU& cpu) {
- // On Athlon X2 CPUs (e.g. model 15) QueryPerformanceCounter is
- // unreliable. Fallback to low-res clock.
- return cpu.vendor_name() == "AuthenticAMD" && cpu.family() == 15;
-}
-
-// Overview of time counters:
+// Discussion of tick counter options on Windows:
+//
// (1) CPU cycle counter. (Retrieved via RDTSC)
// The CPU counter provides the highest resolution time stamp and is the least
-// expensive to retrieve. However, the CPU counter is unreliable and should not
-// be used in production. Its biggest issue is that it is per processor and it
-// is not synchronized between processors. Also, on some computers, the counters
-// will change frequency due to thermal and power changes, and stop in some
-// states.
+// expensive to retrieve. However, on older CPUs, two issues can affect its
+// reliability: First it is maintained per processor and not synchronized
+// between processors. Also, the counters will change frequency due to thermal
+// and power changes, and stop in some states.
//
// (2) QueryPerformanceCounter (QPC). The QPC counter provides a high-
-// resolution (100 nanoseconds) time stamp but is comparatively more expensive
-// to retrieve. What QueryPerformanceCounter actually does is up to the HAL.
-// (with some help from ACPI).
-// According to http://blogs.msdn.com/oldnewthing/archive/2005/09/02/459952.aspx
-// in the worst case, it gets the counter from the rollover interrupt on the
+// resolution (<1 microsecond) time stamp. On most hardware running today, it
+// auto-detects and uses the constant-rate RDTSC counter to provide extremely
+// efficient and reliable time stamps.
+//
+// On older CPUs where RDTSC is unreliable, it falls back to using more
+// expensive (20X to 40X more costly) alternate clocks, such as HPET or the ACPI
+// PM timer, and can involve system calls; and all this is up to the HAL (with
+// some help from ACPI). According to
+// http://blogs.msdn.com/oldnewthing/archive/2005/09/02/459952.aspx, in the
+// worst case, it gets the counter from the rollover interrupt on the
// programmable interrupt timer. In best cases, the HAL may conclude that the
// RDTSC counter runs at a constant frequency, then it uses that instead. On
// multiprocessor machines, it will try to verify the values returned from
// RDTSC on each processor are consistent with each other, and apply a handful
// of workarounds for known buggy hardware. In other words, QPC is supposed to
-// give consistent result on a multiprocessor computer, but it is unreliable in
-// reality due to bugs in BIOS or HAL on some, especially old computers.
-// With recent updates on HAL and newer BIOS, QPC is getting more reliable but
-// it should be used with caution.
+// give consistent results on a multiprocessor computer, but for older CPUs it
+// can be unreliable due bugs in BIOS or HAL.
//
-// (3) System time. The system time provides a low-resolution (typically 10ms
-// to 55 milliseconds) time stamp but is comparatively less expensive to
-// retrieve and more reliable.
-class HighResNowSingleton {
- public:
- HighResNowSingleton()
- : ticks_per_second_(0),
- skew_(0) {
+// (3) System time. The system time provides a low-resolution (from ~1 to ~15.6
+// milliseconds) time stamp but is comparatively less expensive to retrieve and
+// more reliable. Time::EnableHighResolutionTimer() and
+// Time::ActivateHighResolutionTimer() can be called to alter the resolution of
+// this timer; and also other Windows applications can alter it, affecting this
+// one.
- base::CPU cpu;
- if (IsBuggyAthlon(cpu))
- return;
+using NowFunction = TimeTicks (*)(void);
- // Synchronize the QPC clock with GetSystemTimeAsFileTime.
- LARGE_INTEGER ticks_per_sec = {0};
- if (!QueryPerformanceFrequency(&ticks_per_sec))
- return; // QPC is not available.
- ticks_per_second_ = ticks_per_sec.QuadPart;
+TimeTicks InitialNowFunction();
+TimeTicks InitialSystemTraceNowFunction();
- skew_ = UnreliableNow() - ReliableNow();
+// See "threading notes" in InitializeNowFunctionPointers() for details on how
+// concurrent reads/writes to these globals has been made safe.
+NowFunction g_now_function = &InitialNowFunction;
+NowFunction g_system_trace_now_function = &InitialSystemTraceNowFunction;
+int64 g_qpc_ticks_per_second = 0;
+
+// As of January 2015, use of <atomic> is forbidden in Chromium code. This is
+// what std::atomic_thread_fence does on Windows on all Intel architectures when
+// the memory_order argument is anything but std::memory_order_seq_cst:
+#define ATOMIC_THREAD_FENCE(memory_order) _ReadWriteBarrier();
+
+TimeDelta QPCValueToTimeDelta(LONGLONG qpc_value) {
+ // Ensure that the assignment to |g_qpc_ticks_per_second|, made in
+ // InitializeNowFunctionPointers(), has happened by this point.
+ ATOMIC_THREAD_FENCE(memory_order_acquire);
+
+ DCHECK_GT(g_qpc_ticks_per_second, 0);
+
+ // If the QPC Value is below the overflow threshold, we proceed with
+ // simple multiply and divide.
+ if (qpc_value < Time::kQPCOverflowThreshold) {
+ return TimeDelta::FromMicroseconds(
+ qpc_value * Time::kMicrosecondsPerSecond / g_qpc_ticks_per_second);
}
-
- bool IsUsingHighResClock() {
- return ticks_per_second_ != 0;
- }
-
- TimeDelta Now() {
- if (IsUsingHighResClock())
- return TimeDelta::FromMicroseconds(UnreliableNow());
-
- // Just fallback to the slower clock.
- return RolloverProtectedNow();
- }
-
- int64 GetQPCDriftMicroseconds() {
- if (!IsUsingHighResClock())
- return 0;
- return abs((UnreliableNow() - ReliableNow()) - skew_);
- }
-
- int64 QPCValueToMicroseconds(LONGLONG qpc_value) {
- if (!ticks_per_second_)
- return 0;
- // If the QPC Value is below the overflow threshold, we proceed with
- // simple multiply and divide.
- if (qpc_value < Time::kQPCOverflowThreshold)
- return qpc_value * Time::kMicrosecondsPerSecond / ticks_per_second_;
- // Otherwise, calculate microseconds in a round about manner to avoid
- // overflow and precision issues.
- int64 whole_seconds = qpc_value / ticks_per_second_;
- int64 leftover_ticks = qpc_value - (whole_seconds * ticks_per_second_);
- int64 microseconds = (whole_seconds * Time::kMicrosecondsPerSecond) +
- ((leftover_ticks * Time::kMicrosecondsPerSecond) /
- ticks_per_second_);
- return microseconds;
- }
-
- private:
- // Get the number of microseconds since boot in an unreliable fashion.
- int64 UnreliableNow() {
- LARGE_INTEGER now;
- QueryPerformanceCounter(&now);
- return QPCValueToMicroseconds(now.QuadPart);
- }
-
- // Get the number of microseconds since boot in a reliable fashion.
- int64 ReliableNow() {
- return RolloverProtectedNow().InMicroseconds();
- }
-
- int64 ticks_per_second_; // 0 indicates QPF failed and we're broken.
- int64 skew_; // Skew between lo-res and hi-res clocks (for debugging).
-};
-
-static base::LazyInstance<HighResNowSingleton>::Leaky
- leaky_high_res_now_singleton = LAZY_INSTANCE_INITIALIZER;
-
-HighResNowSingleton* GetHighResNowSingleton() {
- return leaky_high_res_now_singleton.Pointer();
+ // Otherwise, calculate microseconds in a round about manner to avoid
+ // overflow and precision issues.
+ int64 whole_seconds = qpc_value / g_qpc_ticks_per_second;
+ int64 leftover_ticks = qpc_value - (whole_seconds * g_qpc_ticks_per_second);
+ return TimeDelta::FromMicroseconds(
+ (whole_seconds * Time::kMicrosecondsPerSecond) +
+ ((leftover_ticks * Time::kMicrosecondsPerSecond) /
+ g_qpc_ticks_per_second));
}
-TimeDelta HighResNowWrapper() {
- return GetHighResNowSingleton()->Now();
+TimeTicks QPCNow() {
+ LARGE_INTEGER now;
+ QueryPerformanceCounter(&now);
+ return TimeTicks() + QPCValueToTimeDelta(now.QuadPart);
}
-typedef TimeDelta (*NowFunction)(void);
+bool IsBuggyAthlon(const base::CPU& cpu) {
+ // On Athlon X2 CPUs (e.g. model 15) QueryPerformanceCounter is unreliable.
+ return cpu.vendor_name() == "AuthenticAMD" && cpu.family() == 15;
+}
-bool CPUReliablySupportsHighResTime() {
+void InitializeNowFunctionPointers() {
+ LARGE_INTEGER ticks_per_sec = {0};
+ if (!QueryPerformanceFrequency(&ticks_per_sec))
+ ticks_per_sec.QuadPart = 0;
+
+ // If Windows cannot provide a QPC implementation, both Now() and
+ // NowFromSystemTraceTime() must use the low-resolution clock.
+ //
+ // If the QPC implementation is expensive and/or unreliable, Now() will use
+ // the low-resolution clock, but NowFromSystemTraceTime() will use the QPC (in
+ // the hope that it is still useful for tracing purposes). A CPU lacking a
+ // non-stop time counter will cause Windows to provide an alternate QPC
+ // implementation that works, but is expensive to use. Certain Athlon CPUs are
+ // known to make the QPC implementation unreliable.
+ //
+ // Otherwise, both Now functions can use the high-resolution QPC clock. As of
+ // 4 January 2015, ~68% of users fall within this category.
+ NowFunction now_function;
+ NowFunction system_trace_now_function;
base::CPU cpu;
- if (!cpu.has_non_stop_time_stamp_counter() ||
- !GetHighResNowSingleton()->IsUsingHighResClock())
- return false;
+ if (ticks_per_sec.QuadPart <= 0) {
+ now_function = system_trace_now_function = &RolloverProtectedNow;
+ } else if (!cpu.has_non_stop_time_stamp_counter() || IsBuggyAthlon(cpu)) {
+ now_function = &RolloverProtectedNow;
+ system_trace_now_function = &QPCNow;
+ } else {
+ now_function = system_trace_now_function = &QPCNow;
+ }
- if (IsBuggyAthlon(cpu))
- return false;
-
- return true;
+ // Threading note 1: In an unlikely race condition, it's possible for two or
+ // more threads to enter InitializeNowFunctionPointers() in parallel. This is
+ // not a problem since all threads should end up writing out the same values
+ // to the global variables.
+ //
+ // Threading note 2: A release fence is placed here to ensure, from the
+ // perspective of other threads using the function pointers, that the
+ // assignment to |g_qpc_ticks_per_second| happens before the function pointers
+ // are changed.
+ g_qpc_ticks_per_second = ticks_per_sec.QuadPart;
+ ATOMIC_THREAD_FENCE(memory_order_release);
+ g_now_function = now_function;
+ g_system_trace_now_function = system_trace_now_function;
}
-TimeDelta InitialNowFunction();
+TimeTicks InitialNowFunction() {
+ InitializeNowFunctionPointers();
+ return g_now_function();
+}
-volatile NowFunction now_function = InitialNowFunction;
-
-TimeDelta InitialNowFunction() {
- if (!CPUReliablySupportsHighResTime()) {
- InterlockedExchangePointer(
- reinterpret_cast<void* volatile*>(&now_function),
- &RolloverProtectedNow);
- return RolloverProtectedNow();
- }
- InterlockedExchangePointer(
- reinterpret_cast<void* volatile*>(&now_function),
- &HighResNowWrapper);
- return HighResNowWrapper();
+TimeTicks InitialSystemTraceNowFunction() {
+ InitializeNowFunctionPointers();
+ return g_system_trace_now_function();
}
} // namespace
@@ -491,27 +483,24 @@
// static
TimeTicks::TickFunctionType TimeTicks::SetMockTickFunction(
TickFunctionType ticker) {
- base::AutoLock locked(rollover_lock);
- TickFunctionType old = tick_function;
- tick_function = ticker;
- rollover_ms = 0;
- last_seen_now = 0;
+ base::AutoLock locked(g_rollover_lock);
+ TickFunctionType old = g_tick_function;
+ g_tick_function = ticker;
+ g_rollover_ms = 0;
+ g_last_seen_now = 0;
return old;
}
// static
TimeTicks TimeTicks::Now() {
- return TimeTicks() + now_function();
+ return g_now_function();
}
// static
-TimeTicks TimeTicks::HighResNow() {
- return TimeTicks() + HighResNowWrapper();
-}
-
-// static
-bool TimeTicks::IsHighResNowFastAndReliable() {
- return CPUReliablySupportsHighResTime();
+bool TimeTicks::IsHighResolution() {
+ if (g_now_function == &InitialNowFunction)
+ InitializeNowFunctionPointers();
+ return g_now_function == &QPCNow;
}
// static
@@ -522,27 +511,17 @@
// static
TimeTicks TimeTicks::NowFromSystemTraceTime() {
- return HighResNow();
-}
-
-// static
-int64 TimeTicks::GetQPCDriftMicroseconds() {
- return GetHighResNowSingleton()->GetQPCDriftMicroseconds();
+ return g_system_trace_now_function();
}
// static
TimeTicks TimeTicks::FromQPCValue(LONGLONG qpc_value) {
- return TimeTicks(GetHighResNowSingleton()->QPCValueToMicroseconds(qpc_value));
-}
-
-// static
-bool TimeTicks::IsHighResClockWorking() {
- return GetHighResNowSingleton()->IsUsingHighResClock();
+ return TimeTicks() + QPCValueToTimeDelta(qpc_value);
}
// TimeDelta ------------------------------------------------------------------
// static
TimeDelta TimeDelta::FromQPCValue(LONGLONG qpc_value) {
- return TimeDelta(GetHighResNowSingleton()->QPCValueToMicroseconds(qpc_value));
+ return QPCValueToTimeDelta(qpc_value);
}
diff --git a/time/time_win_unittest.cc b/time/time_win_unittest.cc
index 058dfd7..71cd29e 100644
--- a/time/time_win_unittest.cc
+++ b/time/time_win_unittest.cc
@@ -6,6 +6,10 @@
#include <mmsystem.h>
#include <process.h>
+#include <cmath>
+#include <limits>
+#include <vector>
+
#include "base/threading/platform_thread.h"
#include "base/time/time.h"
#include "testing/gtest/include/gtest/gtest.h"
@@ -114,7 +118,7 @@
TEST(TimeTicks, SubMillisecondTimers) {
// HighResNow doesn't work on some systems. Since the product still works
// even if it doesn't work, it makes this entire test questionable.
- if (!TimeTicks::IsHighResClockWorking())
+ if (!TimeTicks::IsHighResolution())
return;
const int kRetries = 1000;
@@ -183,7 +187,7 @@
TestCase cases[] = {
{ reinterpret_cast<TestFunc>(Time::Now), "Time::Now" },
{ TimeTicks::Now, "TimeTicks::Now" },
- { TimeTicks::HighResNow, "TimeTicks::HighResNow" },
+ { TimeTicks::NowFromSystemTraceTime, "TimeTicks::NowFromSystemTraceTime" },
{ NULL, "" }
};
@@ -207,65 +211,57 @@
}
}
-// http://crbug.com/396384
-TEST(TimeTicks, DISABLED_Drift) {
- // If QPC is disabled, this isn't measuring anything.
- if (!TimeTicks::IsHighResClockWorking())
- return;
-
- const int kIterations = 100;
- int64 total_drift = 0;
-
- for (int i = 0; i < kIterations; ++i) {
- int64 drift_microseconds = TimeTicks::GetQPCDriftMicroseconds();
-
- // Make sure the drift never exceeds our limit.
- EXPECT_LT(drift_microseconds, 50000);
-
- // Sleep for a few milliseconds (note that it means 1000 microseconds).
- // If we check the drift too frequently, it's going to increase
- // monotonically, making our measurement less realistic.
- base::PlatformThread::Sleep(
- base::TimeDelta::FromMilliseconds((i % 2 == 0) ? 1 : 2));
-
- total_drift += drift_microseconds;
- }
-
- // Sanity check. We expect some time drift to occur, especially across
- // the number of iterations we do.
- EXPECT_LT(0, total_drift);
-
- printf("average time drift in microseconds: %lld\n",
- total_drift / kIterations);
-}
-
-int64 QPCValueToMicrosecondsSafely(LONGLONG qpc_value,
- int64 ticks_per_second) {
- int64 whole_seconds = qpc_value / ticks_per_second;
- int64 leftover_ticks = qpc_value % ticks_per_second;
- int64 microseconds = (whole_seconds * Time::kMicrosecondsPerSecond) +
- ((leftover_ticks * Time::kMicrosecondsPerSecond) /
- ticks_per_second);
- return microseconds;
-}
-
TEST(TimeTicks, FromQPCValue) {
- if (!TimeTicks::IsHighResClockWorking())
+ if (!TimeTicks::IsHighResolution())
return;
+
LARGE_INTEGER frequency;
- QueryPerformanceFrequency(&frequency);
- int64 ticks_per_second = frequency.QuadPart;
- LONGLONG qpc_value = Time::kQPCOverflowThreshold;
- TimeTicks expected_value = TimeTicks::FromInternalValue(
- QPCValueToMicrosecondsSafely(qpc_value + 1, ticks_per_second));
- EXPECT_EQ(expected_value,
- TimeTicks::FromQPCValue(qpc_value + 1));
- expected_value = TimeTicks::FromInternalValue(
- QPCValueToMicrosecondsSafely(qpc_value, ticks_per_second));
- EXPECT_EQ(expected_value,
- TimeTicks::FromQPCValue(qpc_value));
- expected_value = TimeTicks::FromInternalValue(
- QPCValueToMicrosecondsSafely(qpc_value - 1, ticks_per_second));
- EXPECT_EQ(expected_value,
- TimeTicks::FromQPCValue(qpc_value - 1));
+ ASSERT_TRUE(QueryPerformanceFrequency(&frequency));
+ const int64 ticks_per_second = frequency.QuadPart;
+ ASSERT_GT(ticks_per_second, 0);
+
+ // Generate the tick values to convert, advancing the tick count by varying
+ // amounts. These values will ensure that both the fast and overflow-safe
+ // conversion logic in FromQPCValue() is tested, and across the entire range
+ // of possible QPC tick values.
+ std::vector<int64> test_cases;
+ test_cases.push_back(0);
+ const int kNumAdvancements = 100;
+ int64 ticks = 0;
+ int64 ticks_increment = 10;
+ for (int i = 0; i < kNumAdvancements; ++i) {
+ test_cases.push_back(ticks);
+ ticks += ticks_increment;
+ ticks_increment = ticks_increment * 6 / 5;
+ }
+ test_cases.push_back(Time::kQPCOverflowThreshold - 1);
+ test_cases.push_back(Time::kQPCOverflowThreshold);
+ test_cases.push_back(Time::kQPCOverflowThreshold + 1);
+ ticks = Time::kQPCOverflowThreshold + 10;
+ ticks_increment = 10;
+ for (int i = 0; i < kNumAdvancements; ++i) {
+ test_cases.push_back(ticks);
+ ticks += ticks_increment;
+ ticks_increment = ticks_increment * 6 / 5;
+ }
+ test_cases.push_back(std::numeric_limits<int64>::max());
+
+ // Test that the conversions using FromQPCValue() match those computed here
+ // using simple floating-point arithmetic. The floating-point math provides
+ // enough precision to confirm the implementation is correct to the
+ // microsecond for all |test_cases| (though it would be insufficient to
+ // confirm many "very large" tick values which are not being tested here).
+ for (int64 ticks : test_cases) {
+ const double expected_microseconds_since_origin =
+ (static_cast<double>(ticks) * Time::kMicrosecondsPerSecond) /
+ ticks_per_second;
+ const TimeTicks converted_value = TimeTicks::FromQPCValue(ticks);
+ const double converted_microseconds_since_origin =
+ static_cast<double>((converted_value - TimeTicks()).InMicroseconds());
+ EXPECT_NEAR(expected_microseconds_since_origin,
+ converted_microseconds_since_origin,
+ 1.0)
+ << "ticks=" << ticks << ", to be converted via logic path: "
+ << (ticks < Time::kQPCOverflowThreshold ? "FAST" : "SAFE");
+ }
}
diff --git a/values.cc b/values.cc
index b478b62..061b7a1 100644
--- a/values.cc
+++ b/values.cc
@@ -89,6 +89,10 @@
return new Value(TYPE_NULL);
}
+bool Value::GetAsBinary(const BinaryValue** out_value) const {
+ return false;
+}
+
bool Value::GetAsBoolean(bool* out_value) const {
return false;
}
@@ -319,6 +323,12 @@
return new BinaryValue(scoped_buffer_copy.Pass(), size);
}
+bool BinaryValue::GetAsBinary(const BinaryValue** out_value) const {
+ if (out_value)
+ *out_value = this;
+ return true;
+}
+
BinaryValue* BinaryValue::DeepCopy() const {
return CreateWithCopiedBuffer(buffer_.get(), size_);
}
diff --git a/values.h b/values.h
index 4c22f3d..4648283 100644
--- a/values.h
+++ b/values.h
@@ -33,6 +33,7 @@
namespace base {
+class BinaryValue;
class DictionaryValue;
class FundamentalValue;
class ListValue;
@@ -85,6 +86,7 @@
virtual bool GetAsString(std::string* out_value) const;
virtual bool GetAsString(string16* out_value) const;
virtual bool GetAsString(const StringValue** out_value) const;
+ virtual bool GetAsBinary(const BinaryValue** out_value) const;
virtual bool GetAsList(ListValue** out_value);
virtual bool GetAsList(const ListValue** out_value) const;
virtual bool GetAsDictionary(DictionaryValue** out_value);
@@ -188,6 +190,7 @@
const char* GetBuffer() const { return buffer_.get(); }
// Overridden from Value:
+ bool GetAsBinary(const BinaryValue** out_value) const override;
BinaryValue* DeepCopy() const override;
bool Equals(const Value* other) const override;
diff --git a/values_unittest.cc b/values_unittest.cc
index 296880a..b66730b 100644
--- a/values_unittest.cc
+++ b/values_unittest.cc
@@ -127,6 +127,12 @@
ASSERT_NE(stack_buffer, binary->GetBuffer());
ASSERT_EQ(42U, binary->GetSize());
ASSERT_EQ(0, memcmp(stack_buffer, binary->GetBuffer(), binary->GetSize()));
+
+ // Test overloaded GetAsBinary.
+ Value* narrow_value = binary.get();
+ const BinaryValue* narrow_binary = NULL;
+ ASSERT_TRUE(narrow_value->GetAsBinary(&narrow_binary));
+ EXPECT_EQ(binary.get(), narrow_binary);
}
TEST(ValuesTest, StringValue) {
diff --git a/win/message_window.cc b/win/message_window.cc
index 57fe64c..0b4b29f 100644
--- a/win/message_window.cc
+++ b/win/message_window.cc
@@ -7,6 +7,7 @@
#include "base/lazy_instance.h"
#include "base/logging.h"
#include "base/process/memory.h"
+#include "base/profiler/scoped_tracker.h"
#include "base/win/wrapped_window_proc.h"
const wchar_t kMessageWindowClassName[] = L"Chrome_MessageWindow";
@@ -120,6 +121,10 @@
UINT message,
WPARAM wparam,
LPARAM lparam) {
+ // TODO(vadimt): Remove ScopedTracker below once crbug.com/440919 is fixed.
+ tracked_objects::ScopedTracker tracking_profile(
+ FROM_HERE_WITH_EXPLICIT_FUNCTION("440919 MessageWindow::WindowProc"));
+
MessageWindow* self = reinterpret_cast<MessageWindow*>(
GetWindowLongPtr(hwnd, GWLP_USERDATA));
