Bug 792581 - part 19: Replace LL_I2L macro with int64_t cast. r=ehsan
authorAndrew Quartey <andrew.quartey@gmail.com>
Fri, 12 Oct 2012 13:29:11 -0400
changeset 110120 4b8338085eed328b163b46715f91ecd76e450ad6
parent 110119 2aef09336e782afc706117e4882a556724ee3ff7
child 110123 0be7bfea4744e871588a4248c0fe15213fb5d5ff
push id16360
push userandrew.quartey@gmail.com
push dateFri, 12 Oct 2012 17:29:24 +0000
treeherdermozilla-inbound@4b8338085eed [default view] [failures only]
perfherder[talos] [build metrics] [platform microbench] (compared to previous push)
reviewersehsan
bugs792581
milestone19.0a1
first release with
nightly linux32
nightly linux64
nightly mac
nightly win32
nightly win64
last release without
nightly linux32
nightly linux64
nightly mac
nightly win32
nightly win64
Bug 792581 - part 19: Replace LL_I2L macro with int64_t cast. r=ehsan
content/base/src/nsContentSink.cpp
content/base/src/nsDocument.cpp
docshell/base/nsDocShell.h
layout/generic/nsBlockFrame.cpp
netwerk/base/src/nsProtocolProxyService.cpp
netwerk/cache/nsCache.cpp
netwerk/dns/nsHostResolver.cpp
netwerk/protocol/about/nsAboutCache.cpp
netwerk/protocol/about/nsAboutCacheEntry.cpp
tools/trace-malloc/spacetrace.c
uriloader/prefetch/nsPrefetchService.cpp
xpcom/ds/nsVariant.cpp
xpcom/glue/nsTextFormatter.cpp
xpcom/io/nsLocalFileOS2.cpp
xpcom/io/nsLocalFileWin.cpp
xpcom/reflect/xptcall/tests/TestXPTCInvoke.cpp
xpcom/tests/CvtURL.cpp
--- a/content/base/src/nsContentSink.cpp
+++ b/content/base/src/nsContentSink.cpp
@@ -1220,19 +1220,18 @@ nsContentSink::Notify(nsITimer *timer)
     // We shouldn't interfere with our normal DidProcessAToken logic
     mDroppedTimer = true;
     return NS_OK;
   }
   
 #ifdef MOZ_DEBUG
   {
     PRTime now = PR_Now();
-    int64_t interval;
 
-    LL_I2L(interval, GetNotificationInterval());
+    int64_t interval = GetNotificationInterval();
     delay = int32_t(now - mLastNotificationTime - interval) / PR_USEC_PER_MSEC;
 
     mBackoffCount--;
     SINK_TRACE(gContentSinkLogModuleInfo, SINK_TRACE_REFLOW,
                ("nsContentSink::Notify: reflow on a timer: %d milliseconds "
                 "late, backoff count: %d", delay, mBackoffCount));
   }
 #endif
--- a/content/base/src/nsDocument.cpp
+++ b/content/base/src/nsDocument.cpp
@@ -6869,19 +6869,17 @@ nsDocument::RetrieveRelevantHeaders(nsIC
     if (fileChannel) {
       nsCOMPtr<nsIFile> file;
       fileChannel->GetFile(getter_AddRefs(file));
       if (file) {
         PRTime msecs;
         rv = file->GetLastModifiedTime(&msecs);
 
         if (NS_SUCCEEDED(rv)) {
-          int64_t intermediateValue;
-          LL_I2L(intermediateValue, PR_USEC_PER_MSEC);
-          modDate = msecs * intermediateValue;
+          modDate = msecs * int64_t(PR_USEC_PER_MSEC);
         }
       }
     } else {
       nsAutoCString contentDisp;
       rv = aChannel->GetContentDispositionHeader(contentDisp);
       if (NS_SUCCEEDED(rv)) {
         SetHeaderData(nsGkAtoms::headerContentDisposition,
                       NS_ConvertASCIItoUTF16(contentDisp));
--- a/docshell/base/nsDocShell.h
+++ b/docshell/base/nsDocShell.h
@@ -527,20 +527,18 @@ protected:
     bool IsNavigationAllowed(bool aDisplayPrintErrorDialog = true);
     bool IsPrintingOrPP(bool aDisplayErrorDialog = true);
 
     nsresult SetBaseUrlForWyciwyg(nsIContentViewer * aContentViewer);
 
     static  inline  uint32_t
     PRTimeToSeconds(PRTime t_usec)
     {
-      PRTime usec_per_sec;
-      LL_I2L(usec_per_sec, PR_USEC_PER_SEC);
-      t_usec /= usec_per_sec;
-      return  uint32_t(t_usec);
+      PRTime usec_per_sec = PR_USEC_PER_SEC;
+      return  uint32_t(t_usec /= usec_per_sec);
     }
 
     bool IsFrame();
 
     //
     // Helper method that is called when a new document (including any
     // sub-documents - ie. frames) has been completely loaded.
     //
--- a/layout/generic/nsBlockFrame.cpp
+++ b/layout/generic/nsBlockFrame.cpp
@@ -1231,17 +1231,17 @@ nsBlockFrame::Reflow(nsPresContext*     
 
   if (gLameReflowMetrics) {
     PRTime end = PR_Now();
 
     int32_t ectc = nsLineBox::GetCtorCount();
     int32_t numLines = mLines.size();
     if (!numLines) numLines = 1;
     PRTime delta, perLineDelta, lines;
-    LL_I2L(lines, numLines);
+    lines = int64_t(numLines);
     delta = end - start;
     perLineDelta = delta / lines;
 
     ListTag(stdout);
     char buf[400];
     PR_snprintf(buf, sizeof(buf),
                 ": %lld elapsed (%lld per line) (%d lines; %d new lines)",
                 delta, perLineDelta, numLines, ectc - ctc);
@@ -6202,17 +6202,17 @@ nsBlockFrame::BuildDisplayList(nsDisplay
 
 #ifdef DEBUG
   if (gLamePaintMetrics) {
     PRTime end = PR_Now();
 
     int32_t numLines = mLines.size();
     if (!numLines) numLines = 1;
     PRTime lines, deltaPerLine, delta;
-    LL_I2L(lines, numLines);
+    lines = int64_t(numLines);
     delta = end - start;
     deltaPerLine = delta / lines;
 
     ListTag(stdout);
     char buf[400];
     PR_snprintf(buf, sizeof(buf),
                 ": %lld elapsed (%lld per line) lines=%d drawn=%d skip=%d",
                 delta, deltaPerLine,
--- a/netwerk/base/src/nsProtocolProxyService.cpp
+++ b/netwerk/base/src/nsProtocolProxyService.cpp
@@ -777,19 +777,17 @@ uint32_t
 nsProtocolProxyService::SecondsSinceSessionStart()
 {
     PRTime now = PR_Now();
 
     // get time elapsed since session start
     int64_t diff = now - mSessionStart;
 
     // convert microseconds to seconds
-    PRTime ups;
-    LL_I2L(ups, PR_USEC_PER_SEC);
-    diff /= ups;
+    diff /= PR_USEC_PER_SEC;
 
     // return converted 32 bit value
     return uint32_t(diff);
 }
 
 void
 nsProtocolProxyService::EnableProxy(nsProxyInfo *pi)
 {
--- a/netwerk/cache/nsCache.cpp
+++ b/netwerk/cache/nsCache.cpp
@@ -40,31 +40,28 @@ CacheLogPrintPath(PRLogModuleLevel level
 }
 
 #endif
 
 
 uint32_t
 SecondsFromPRTime(PRTime prTime)
 {
-  int64_t  microSecondsPerSecond;
-  LL_I2L(microSecondsPerSecond, PR_USEC_PER_SEC);
+  int64_t  microSecondsPerSecond = PR_USEC_PER_SEC;
   return uint32_t(prTime / microSecondsPerSecond);
 }
 
 
 PRTime
 PRTimeFromSeconds(uint32_t seconds)
 {
-  int64_t microSecondsPerSecond, intermediateResult;
-  PRTime  prTime;
+  int64_t intermediateResult;
 
-  LL_I2L(microSecondsPerSecond, PR_USEC_PER_SEC);
   LL_UI2L(intermediateResult, seconds);
-  prTime = intermediateResult * microSecondsPerSecond;
+  PRTime prTime = intermediateResult * PR_USEC_PER_SEC;
   return prTime;
 }
 
 
 nsresult
 ClientIDFromCacheKey(const nsACString&  key, char ** result)
 {
     nsresult  rv = NS_OK;
--- a/netwerk/dns/nsHostResolver.cpp
+++ b/netwerk/dns/nsHostResolver.cpp
@@ -83,19 +83,17 @@ MoveCList(PRCList &from, PRCList &to)
         to.prev->next = &to;
         PR_INIT_CLIST(&from);
     }             
 }
 
 static uint32_t
 NowInMinutes()
 {
-    PRTime now = PR_Now(), factor;
-    LL_I2L(factor, 60 * PR_USEC_PER_SEC);
-    return uint32_t(now / factor);
+    return uint32_t(PR_Now() / int64_t(60 * PR_USEC_PER_SEC));
 }
 
 //----------------------------------------------------------------------------
 
 #if defined(RES_RETRY_ON_FAILURE)
 
 // this class represents the resolver state for a given thread.  if we
 // encounter a lookup failure, then we can invoke the Reset method on an
--- a/netwerk/protocol/about/nsAboutCache.cpp
+++ b/netwerk/protocol/about/nsAboutCache.cpp
@@ -16,20 +16,19 @@
 #include "prtime.h"
 #include "nsEscape.h"
 
 #include "nsICacheService.h"
 
 static PRTime SecondsToPRTime(uint32_t t_sec)
 {
     PRTime t_usec, usec_per_sec;
-    LL_I2L(t_usec, t_sec);
-    LL_I2L(usec_per_sec, PR_USEC_PER_SEC);
-    t_usec *= usec_per_sec;
-    return t_usec;
+    t_usec = t_sec;
+    usec_per_sec = PR_USEC_PER_SEC;
+    return t_usec *= usec_per_sec;
 }
 static void PrintTimeString(char *buf, uint32_t bufsize, uint32_t t_sec)
 {
     PRExplodedTime et;
     PRTime t_usec = SecondsToPRTime(t_sec);
     PR_ExplodeTime(t_usec, PR_LocalTimeParameters, &et);
     PR_FormatTime(buf, bufsize, "%Y-%m-%d %H:%M:%S", &et);
 }
--- a/netwerk/protocol/about/nsAboutCacheEntry.cpp
+++ b/netwerk/protocol/about/nsAboutCacheEntry.cpp
@@ -173,20 +173,19 @@ nsAboutCacheEntry::OpenCacheEntry(nsIURI
 
 //-----------------------------------------------------------------------------
 // helper methods
 //-----------------------------------------------------------------------------
 
 static PRTime SecondsToPRTime(uint32_t t_sec)
 {
     PRTime t_usec, usec_per_sec;
-    LL_I2L(t_usec, t_sec);
-    LL_I2L(usec_per_sec, PR_USEC_PER_SEC);
-    t_usec *= usec_per_sec;
-    return t_usec;
+    t_usec = t_sec;
+    usec_per_sec = PR_USEC_PER_SEC;
+    return t_usec *= usec_per_sec;
 }
 static void PrintTimeString(char *buf, uint32_t bufsize, uint32_t t_sec)
 {
     PRExplodedTime et;
     PRTime t_usec = SecondsToPRTime(t_sec);
     PR_ExplodeTime(t_usec, PR_LocalTimeParameters, &et);
     PR_FormatTime(buf, bufsize, "%Y-%m-%d %H:%M:%S", &et);
 }
--- a/tools/trace-malloc/spacetrace.c
+++ b/tools/trace-malloc/spacetrace.c
@@ -3864,19 +3864,19 @@ graphFootprint(STRequest * inRequest, ST
                      */
                     for (traverse = 0; traverse < STGD_SPACE_X; traverse++) {
                         x1 = traverse + STGD_MARGIN;
                         y1 = STGD_HEIGHT - STGD_MARGIN;
 
                         /*
                          ** Need to do this math in 64 bits.
                          */
-                        LL_I2L(ydata64, YData[traverse]);
-                        LL_I2L(spacey64, STGD_SPACE_Y);
-                        LL_I2L(mem64, (maxMemory - minMemory));
+                        ydata64 = (int64_t)YData[traverse];
+                        spacey64 = (int64_t)STGD_SPACE_Y;
+                        mem64 = (int64_t)(maxMemory - minMemory);
 
                         in64 = ydata64 * spacey64;
                         in64 /= mem64;
                         in32 = int32_t(in64);
 
                         x2 = x1;
                         y2 = y1 - in32;
 
@@ -4080,19 +4080,19 @@ graphTimeval(STRequest * inRequest, STRu
                      */
                     for (traverse = 0; traverse < STGD_SPACE_X; traverse++) {
                         x1 = traverse + STGD_MARGIN;
                         y1 = STGD_HEIGHT - STGD_MARGIN;
 
                         /*
                          ** Need to do this math in 64 bits.
                          */
-                        LL_I2L(ydata64, YData[traverse]);
-                        LL_I2L(spacey64, STGD_SPACE_Y);
-                        LL_I2L(mem64, (maxMemory - minMemory));
+                        ydata64 = (int64_t)YData[traverse];
+                        spacey64 = (int64_t)STGD_SPACE_Y;
+                        mem64 = (int64_t)(maxMemory - minMemory);
 
                         in64 = ydata64 * spacey64;
                         in64 /= mem64;
                         in32 = int32_t(in64);
 
                         x2 = x1;
                         y2 = y1 - in32;
 
@@ -4298,19 +4298,19 @@ graphLifespan(STRequest * inRequest, STR
                      */
                     for (traverse = 0; traverse < STGD_SPACE_X; traverse++) {
                         x1 = traverse + STGD_MARGIN;
                         y1 = STGD_HEIGHT - STGD_MARGIN;
 
                         /*
                          ** Need to do this math in 64 bits.
                          */
-                        LL_I2L(ydata64, YData[traverse]);
-                        LL_I2L(spacey64, STGD_SPACE_Y);
-                        LL_I2L(mem64, (maxMemory - minMemory));
+                        ydata64 = (int64_t)YData[traverse];
+                        spacey64 = (int64_t)STGD_SPACE_Y;
+                        mem64 = (int64_t)(maxMemory - minMemory);
 
                         in64 = ydata64 * spacey64;
                         in64 /= mem64;
                         in32 = int32_t(in64);
 
                         x2 = x1;
                         y2 = y1 - in32;
 
@@ -4531,17 +4531,17 @@ graphWeight(STRequest * inRequest, STRun
                      */
                     for (traverse = 0; traverse < STGD_SPACE_X; traverse++) {
                         x1 = traverse + STGD_MARGIN;
                         y1 = STGD_HEIGHT - STGD_MARGIN;
 
                         /*
                          ** Need to do this math in 64 bits.
                          */
-                        LL_I2L(spacey64, STGD_SPACE_Y);
+                        spacey64 = (int64_t)STGD_SPACE_Y;
                         weight64 = maxWeight64 - minWeight64;
 
                         in64 = YData64[traverse] * spacey64;
                         in64 /= weight64;
                         in32 = int32_t(in64);
 
                         x2 = x1;
                         y2 = y1 - in32;
--- a/uriloader/prefetch/nsPrefetchService.cpp
+++ b/uriloader/prefetch/nsPrefetchService.cpp
@@ -52,20 +52,18 @@ static PRLogModuleInfo *gPrefetchLog;
 
 //-----------------------------------------------------------------------------
 // helpers
 //-----------------------------------------------------------------------------
 
 static inline uint32_t
 PRTimeToSeconds(PRTime t_usec)
 {
-    PRTime usec_per_sec;
-    LL_I2L(usec_per_sec, PR_USEC_PER_SEC);
-    t_usec /= usec_per_sec;
-    return uint32_t(t_usec);
+    PRTime usec_per_sec = PR_USEC_PER_SEC;
+    return uint32_t(t_usec /= usec_per_sec);
 }
 
 #define NowInSeconds() PRTimeToSeconds(PR_Now())
 
 //-----------------------------------------------------------------------------
 // nsPrefetchQueueEnumerator
 //-----------------------------------------------------------------------------
 class nsPrefetchQueueEnumerator MOZ_FINAL : public nsISimpleEnumerator
--- a/xpcom/ds/nsVariant.cpp
+++ b/xpcom/ds/nsVariant.cpp
@@ -642,17 +642,17 @@ nsVariant::ConvertToInt64(const nsDiscri
     nsDiscriminatedUnion tempData;
     nsVariant::Initialize(&tempData);
     nsresult rv = ToManageableNumber(data, &tempData);
     if(NS_FAILED(rv))
         return rv;
     switch(tempData.mType)
     {
     case nsIDataType::VTYPE_INT32:
-        LL_I2L(*_retval, tempData.u.mInt32Value);
+        *_retval = tempData.u.mInt32Value;
         return rv;
     case nsIDataType::VTYPE_UINT32:
         LL_UI2L(*_retval, tempData.u.mUint32Value);
         return rv;
     case nsIDataType::VTYPE_DOUBLE:
         // XXX should check for data loss here!
         LL_D2L(*_retval, tempData.u.mDoubleValue);
         return rv;
--- a/xpcom/glue/nsTextFormatter.cpp
+++ b/xpcom/glue/nsTextFormatter.cpp
@@ -282,17 +282,17 @@ static int cvt_ll(SprintfState *ss, int6
 	return 0;
     }
 
     /*
     ** Converting decimal is a little tricky. In the unsigned case we
     ** need to stop when we hit 10 digits. In the signed case, we can
     ** stop when the number is zero.
     */
-    LL_I2L(rad, radix);
+    rad = radix;
     cvt = &cvtbuf[0] + ELEMENTS_OF(cvtbuf);
     digits = 0;
     while (num != 0) {
 	int64_t quot, rem;
 	LL_UDIVMOD(&quot, &rem, num, rad);
 	int32_t digit = int32_t(rem);
 	*--cvt = hexp[digit & 0xf];
 	digits++;
--- a/xpcom/io/nsLocalFileOS2.cpp
+++ b/xpcom/io/nsLocalFileOS2.cpp
@@ -1709,19 +1709,17 @@ nsLocalFile::GetLastModifiedTime(PRTime 
     NS_ENSURE_ARG(aLastModifiedTime);
 
     *aLastModifiedTime = 0;
     nsresult rv = Stat();
     if (NS_FAILED(rv))
         return rv;
 
     // microseconds -> milliseconds
-    int64_t usecPerMsec;
-    LL_I2L(usecPerMsec, PR_USEC_PER_MSEC);
-    *aLastModifiedTime = mFileInfo64.modifyTime / usecPerMsec;
+    *aLastModifiedTime = mFileInfo64.modifyTime / PR_USEC_PER_MSEC;
     return NS_OK;
 }
 
 
 NS_IMETHODIMP
 nsLocalFile::GetLastModifiedTimeOfLink(PRTime *aLastModifiedTime)
 {
     return NS_ERROR_NOT_IMPLEMENTED;
--- a/xpcom/io/nsLocalFileWin.cpp
+++ b/xpcom/io/nsLocalFileWin.cpp
@@ -2261,19 +2261,17 @@ nsLocalFile::GetLastModifiedTime(PRTime 
     // otherwise it will be for the shortcut file itself (i.e. the same 
     // results as GetLastModifiedTimeOfLink)
 
     nsresult rv = ResolveAndStat();
     if (NS_FAILED(rv))
         return rv;
 
     // microseconds -> milliseconds
-    int64_t usecPerMsec;
-    LL_I2L(usecPerMsec, PR_USEC_PER_MSEC);
-    *aLastModifiedTime = mFileInfo64.modifyTime / usecPerMsec;
+    *aLastModifiedTime = mFileInfo64.modifyTime / PR_USEC_PER_MSEC;
     return NS_OK;
 }
 
 
 NS_IMETHODIMP
 nsLocalFile::GetLastModifiedTimeOfLink(PRTime *aLastModifiedTime)
 {
     // Check we are correctly initialized.
@@ -2285,19 +2283,17 @@ nsLocalFile::GetLastModifiedTimeOfLink(P
     // and to have found that this file is a link. 
 
     PRFileInfo64 info;
     nsresult rv = GetFileInfo(mWorkingPath, &info);
     if (NS_FAILED(rv)) 
         return rv;
 
     // microseconds -> milliseconds
-    int64_t usecPerMsec;
-    LL_I2L(usecPerMsec, PR_USEC_PER_MSEC);
-    *aLastModifiedTime = info.modifyTime / usecPerMsec;
+    *aLastModifiedTime = info.modifyTime / PR_USEC_PER_MSEC;
     return NS_OK;
 }
 
 
 NS_IMETHODIMP
 nsLocalFile::SetLastModifiedTime(PRTime aLastModifiedTime)
 {
     // Check we are correctly initialized.
--- a/xpcom/reflect/xptcall/tests/TestXPTCInvoke.cpp
+++ b/xpcom/reflect/xptcall/tests/TestXPTCInvoke.cpp
@@ -318,19 +318,17 @@ int main()
     int32_t out, tmp32 = 0;
     int64_t out64;
     nsresult failed_rv;
     printf("calling direct:\n");
     if(NS_SUCCEEDED(test->AddTwoInts(1,1,&out)))
         printf("\t1 + 1 = %d\n", out);
     else
         printf("\tFAILED");
-    int64_t one, two;
-    LL_I2L(one, 1);
-    LL_I2L(two, 2);
+    int64_t one = 1, two = 2;
     if(NS_SUCCEEDED(test->AddTwoLLs(one,one,&out64)))
     {
         tmp32 = (int)out64;
         printf("\t1L + 1L = %d\n", tmp32);
     }
     else
         printf("\tFAILED");
     if(NS_SUCCEEDED(test->MultTwoInts(2,2,&out)))
@@ -430,25 +428,25 @@ int main()
     var[2].flags = nsXPTCVariant::PTR_IS_DATA;
     var[2].ptr = &var[2].val.i32;
 
     if(NS_SUCCEEDED(NS_InvokeByIndex(test, 3, 3, var)))
         printf("\t1 + 1 = %d\n", var[2].val.i32);
     else
         printf("\tFAILED");
 
-    LL_I2L(var[0].val.i64, 1);
+    var[0].val.i64 = 1;
     var[0].type = nsXPTType::T_I64;
     var[0].flags = 0;
 
-    LL_I2L(var[1].val.i64, 1);
+    var[1].val.i64 = 1;
     var[1].type = nsXPTType::T_I64;
     var[1].flags = 0;
 
-    LL_I2L(var[2].val.i64, 0);
+    var[2].val.i64 = 0;
     var[2].type = nsXPTType::T_I64;
     var[2].flags = nsXPTCVariant::PTR_IS_DATA;
     var[2].ptr = &var[2].val.i64;
 
     if(NS_SUCCEEDED(NS_InvokeByIndex(test, 5, 3, var)))
         printf("\t1L + 1L = %d\n", (int)var[2].val.i64);
     else
         printf("\tFAILED");
@@ -466,25 +464,25 @@ int main()
     var[2].flags = nsXPTCVariant::PTR_IS_DATA;
     var[2].ptr = &var[2].val.i32;
 
     if(NS_SUCCEEDED(NS_InvokeByIndex(test, 4, 3, var)))
         printf("\t2 * 2 = %d\n", var[2].val.i32);
     else
         printf("\tFAILED");
 
-    LL_I2L(var[0].val.i64,2);
+    var[0].val.i64 = 2;
     var[0].type = nsXPTType::T_I64;
     var[0].flags = 0;
 
-    LL_I2L(var[1].val.i64,2);
+    var[1].val.i64 = 2;
     var[1].type = nsXPTType::T_I64;
     var[1].flags = 0;
 
-    LL_I2L(var[2].val.i64,0);
+    var[2].val.i64 = 0;
     var[2].type = nsXPTType::T_I64;
     var[2].flags = nsXPTCVariant::PTR_IS_DATA;
     var[2].ptr = &var[2].val.i64;
 
     if(NS_SUCCEEDED(NS_InvokeByIndex(test, 6, 3, var)))
         printf("\t2L * 2L = %d\n", (int)var[2].val.i64);
     else
         printf("\tFAILED");
--- a/xpcom/tests/CvtURL.cpp
+++ b/xpcom/tests/CvtURL.cpp
@@ -71,19 +71,17 @@ int main(int argc, char** argv)
     if (NS_FAILED(ec)) {
       printf("i/o error: %d\n", ec);
       break;
     }
     if (nb == 0) break; // EOF
     count += nb;
   }
   PRTime end = PR_Now();
-  PRTime conversion, ustoms;
-  LL_I2L(ustoms, 1000);
-  conversion = (end - start) / ustoms;
+  PRTime conversion = (end - start) / 1000;
   char buf[500];
   PR_snprintf(buf, sizeof(buf),
               "converting and discarding %d bytes took %lldms",
               count, conversion);
   puts(buf);
 
   // Release the objects
   in->Release();