Issue 5167 - Update to use libadblockplus revision dca8df9af1a7

libadblockplus-android/jni/Utils.h

 /*
  * This file is part of Adblock Plus <https://adblockplus.org/>,
  * Copyright (C) 2006-2017 eyeo GmbH
  *
  * Adblock Plus is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License version 3 as
  * published by the Free Software Foundation.
  *
  * Adblock Plus is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
@@ skipping 169 matching lines @@
   return (int64_t)env->GetLongField(jObj, env->GetFieldID(clazz, name, "J"));
 }
 
 inline jobjectArray JniGetStringArrayField(JNIEnv* env, jclass clazz, jobject jObj, const char* name)
 {
   return (jobjectArray)env->GetObjectField(jObj, env->GetFieldID(clazz, name, "[Ljava/lang/String;"));
 }
 
 jobject NewJniArrayList(JNIEnv* env);
 
-jobject NewJniFilter(JNIEnv* env, const AdblockPlus::FilterPtr& filter);
+jobject NewJniFilter(JNIEnv* env, AdblockPlus::Filter& filter);

[sergei, 2017/04/26 09:21:00]

here and below the argument types should be const references, e.g. `const
Filter&`. However, I think it's very important to actually add methods accepting
r-value references and move the value in the implementation (see comments for
cpp file).

e.g.
jobject NewJniFilter(JNIEnv* env, AdblockPlus::Filter&& filter);

PS:
I would recommend to comment methods, accepting const reference, while making
these changes and see where they are required from, most likely we can get rid
of copying values. It will improve the efficiency.

[anton, 2017/04/26 10:22:59]

I agree to have optimized methods but following is unclear:
engine returns instances (not pointers) then the content is moved to the new
instance (created by jni layer). why filter engine can't just return pointers
instead of objects? eg. `Subscription subscription =
filterEngine->getSubscription(); Subscription *copy = .. move(subscription)` -> 
`Subscription*`

[sergei, 2017/04/26 14:12:56]

Because it's a bad design to return a pointer when we know that the value of the
pointer never can be nullptr, and in addition returning the pointer means an
additional memory allocation on a heap, however it's not required. If someone,
like this android code, has to move the object to the heap then it should do it.

What about methods accepting r-value references?

[anton, 2017/04/27 06:21:01]

i will use r-values and move ctors

 
-jobject NewJniSubscription(JNIEnv* env,
-    const AdblockPlus::SubscriptionPtr& subscription);
+jobject NewJniSubscription(JNIEnv* env, AdblockPlus::Subscription& subscription);
 
-jobject NewJniNotification(JNIEnv* env,
-    const AdblockPlus::NotificationPtr& notification);
+jobject NewJniNotification(JNIEnv* env, AdblockPlus::Notification& notification);
 
 #define CATCH_AND_THROW(jEnv) \
   catch (const std::exception& except) \
   { \
     JniThrowException(jEnv, except); \
   } \
   catch (...) \
   { \
     JniThrowException(jEnv); \
   }
 
 #define CATCH_THROW_AND_RETURN(jEnv, retVal) \
   catch (const std::exception& except) \
   { \
     JniThrowException(jEnv, except); \
     return retVal; \
   } \
   catch (...) \
   { \
     JniThrowException(jEnv); \
     return retVal; \
   }
 
 #endif