Clean up decoding well-known classes.

Test: m test-art-host-gtest
Test: testrunner.py --host --optimizing
Change-Id: I27b4e8f5513511ce1c320e3224dd9c2a40880b69

1 files changed, 14 insertions, 19 deletions

diff --git a/runtime/class_loader_utils.h b/runtime/class_loader_utils.h
index aabc4ca91d..eae31cce30 100644
--- a/runtime/class_loader_utils.h
+++ b/runtime/class_loader_utils.h
@@ -31,41 +31,37 @@
 namespace art {
 
 // Returns true if the given class loader derives from BaseDexClassLoader.
-inline bool IsInstanceOfBaseDexClassLoader(ScopedObjectAccessAlreadyRunnable& soa,
-                                           Handle<mirror::ClassLoader> class_loader)
+inline bool IsInstanceOfBaseDexClassLoader(Handle<mirror::ClassLoader> class_loader)
     REQUIRES_SHARED(Locks::mutator_lock_) {
   return class_loader->InstanceOf(
-      soa.Decode<mirror::Class>(WellKnownClasses::dalvik_system_BaseDexClassLoader));
+      WellKnownClasses::ToClass(WellKnownClasses::dalvik_system_BaseDexClassLoader));
 }
 
 // Returns true if the given class loader is either a PathClassLoader or a DexClassLoader.
 // (they both have the same behaviour with respect to class lookup order)
-inline bool IsPathOrDexClassLoader(ScopedObjectAccessAlreadyRunnable& soa,
-                                   Handle<mirror::ClassLoader> class_loader)
+inline bool IsPathOrDexClassLoader(Handle<mirror::ClassLoader> class_loader)
     REQUIRES_SHARED(Locks::mutator_lock_) {
   ObjPtr<mirror::Class> class_loader_class = class_loader->GetClass();
   return
       (class_loader_class ==
-          soa.Decode<mirror::Class>(WellKnownClasses::dalvik_system_PathClassLoader)) ||
+          WellKnownClasses::ToClass(WellKnownClasses::dalvik_system_PathClassLoader)) ||
       (class_loader_class ==
-          soa.Decode<mirror::Class>(WellKnownClasses::dalvik_system_DexClassLoader));
+          WellKnownClasses::ToClass(WellKnownClasses::dalvik_system_DexClassLoader));
 }
 
 // Returns true if the given class loader is an InMemoryDexClassLoader.
-inline bool IsInMemoryDexClassLoader(ScopedObjectAccessAlreadyRunnable& soa,
-                                     Handle<mirror::ClassLoader> class_loader)
+inline bool IsInMemoryDexClassLoader(Handle<mirror::ClassLoader> class_loader)
     REQUIRES_SHARED(Locks::mutator_lock_) {
   ObjPtr<mirror::Class> class_loader_class = class_loader->GetClass();
   return (class_loader_class ==
-      soa.Decode<mirror::Class>(WellKnownClasses::dalvik_system_InMemoryDexClassLoader));
+      WellKnownClasses::ToClass(WellKnownClasses::dalvik_system_InMemoryDexClassLoader));
 }
 
-inline bool IsDelegateLastClassLoader(ScopedObjectAccessAlreadyRunnable& soa,
-                                      Handle<mirror::ClassLoader> class_loader)
+inline bool IsDelegateLastClassLoader(Handle<mirror::ClassLoader> class_loader)
     REQUIRES_SHARED(Locks::mutator_lock_) {
   ObjPtr<mirror::Class> class_loader_class = class_loader->GetClass();
   return class_loader_class ==
-      soa.Decode<mirror::Class>(WellKnownClasses::dalvik_system_DelegateLastClassLoader);
+      WellKnownClasses::ToClass(WellKnownClasses::dalvik_system_DelegateLastClassLoader);
 }
 
 // Visit the DexPathList$Element instances in the given classloader with the given visitor.
@@ -75,12 +71,11 @@ inline bool IsDelegateLastClassLoader(ScopedObjectAccessAlreadyRunnable& soa,
 //     when the visitor ends the visit (by returning false).
 // This function assumes that the given classloader is a subclass of BaseDexClassLoader!
 template <typename Visitor, typename RetType>
-inline RetType VisitClassLoaderDexElements(ScopedObjectAccessAlreadyRunnable& soa,
+inline RetType VisitClassLoaderDexElements(Thread* self,
                                            Handle<mirror::ClassLoader> class_loader,
                                            Visitor fn,
                                            RetType defaultReturn)
     REQUIRES_SHARED(Locks::mutator_lock_) {
-  Thread* self = soa.Self();
   ObjPtr<mirror::Object> dex_path_list =
       WellKnownClasses::dalvik_system_BaseDexClassLoader_pathList->GetObject(class_loader.Get());
   if (dex_path_list != nullptr) {
@@ -115,7 +110,7 @@ inline RetType VisitClassLoaderDexElements(ScopedObjectAccessAlreadyRunnable& so
 //     when the visitor ends the visit (by returning false).
 // This function assumes that the given classloader is a subclass of BaseDexClassLoader!
 template <typename Visitor, typename RetType>
-inline RetType VisitClassLoaderDexFiles(ScopedObjectAccessAlreadyRunnable& soa,
+inline RetType VisitClassLoaderDexFiles(Thread* self,
                                         Handle<mirror::ClassLoader> class_loader,
                                         Visitor fn,
                                         RetType defaultReturn)
@@ -151,12 +146,12 @@ inline RetType VisitClassLoaderDexFiles(ScopedObjectAccessAlreadyRunnable& soa,
     return true;
   };
 
-  return VisitClassLoaderDexElements(soa, class_loader, visit_dex_files, defaultReturn);
+  return VisitClassLoaderDexElements(self, class_loader, visit_dex_files, defaultReturn);
 }
 
 // Simplified version of the above, w/o out argument.
 template <typename Visitor>
-inline void VisitClassLoaderDexFiles(ScopedObjectAccessAlreadyRunnable& soa,
+inline void VisitClassLoaderDexFiles(Thread* self,
                                      Handle<mirror::ClassLoader> class_loader,
                                      Visitor fn)
     REQUIRES_SHARED(Locks::mutator_lock_) {
@@ -170,7 +165,7 @@ inline void VisitClassLoaderDexFiles(ScopedObjectAccessAlreadyRunnable& soa,
 
     return fn(dex_file);
   };
-  VisitClassLoaderDexFiles<decltype(helper), void*>(soa,
+  VisitClassLoaderDexFiles<decltype(helper), void*>(self,
                                                     class_loader,
                                                     helper,
                                                     /* defaultReturn= */ nullptr);